# Java Syntax



## BillyFitt (23. Nov 2016)

Hallo
Ich hab das folgende Programm geschrieben:


```
public class Intersection {
/*
requires a != null
ensures \result == (es existiert ein int i in [0,a.length -1], so dass a[i] == x)
*/
public static boolean contains(int[] a, int x) {
return false; // TODO
}
/*
requires a != null
ensures \result == (für alle int i in [0,a.length -2]: a[i] < a[i+1])
*/
public static boolean increasing (int[] a) {
return false; // TODO
}
/*
requires a != null
&& b != null
&& increasing(a)
&& increasing(b)
ensures \result != null
&& für alle int x: (contains(a, x) && contains(b, x)) == contains(\result , x)
&& increasing(\result)
*/
public static int[] intersection (int[] a, int[] b) {
return null; // TODO
}
}
```

Ich weiß noch nicht genau die Syntax der Programmiersprache Java und deshalb habe ich Kommentare gemacht, in die steht was ich machen will. Würde mich sehr freuen wenn jemand mir helfen konnte. Vielen Dank im Voraus!


----------



## JCODA (23. Nov 2016)

Wenn du nur das Gerüst aus der Aufgabenstellung kopierst, kann ich dir höchstens so helfen: http://www.java-forum.org/thema/biete-nachhilfe-in-java-python-mathe-an.175301/


----------



## prise1993 (24. Nov 2016)

Wenn ich das richtig verstanden habe, soll die Methode intersection() ein int Array zurück geben in dem die Werte gespeichert werden die in a und b vorkommen? Ich hab das jetzt mal so gemacht das er dir ein Array mit Nullen gefüllt zurückgibt wenn die Bedingungen nicht erfüllt sind, da ja result != null sein darf.

```
/*requires a != null
ensures \result == (es existiert ein int i in [0,a.length -1], so dass a[i] == x)
*/
    public static boolean contains(int[] a, int x) {

        if(a == null)
            return false;
        for (int i:a) {
            if (i == x)
                return true;
        }
        return false;
    }
    /*
    requires a != null
    ensures \result == (für alle int i in [0,a.length -2]: a[i] < a[i+1])
    */
    public static boolean increasing (int[] a) {

        if (a == null)
            return false;
        for (int i = 0; i < a.length-1; i++) {
            if (a[i] >= a[i+1])
                return false;
        }
        return true;
    }
    /*
    requires a != null
    && b != null
    && increasing(a)
    && increasing(b)
    ensures \result != nu
    && für alle int x: (contains(a, x) && contains(b, x)) == contains(\result , x)
    && increasing(\result)
    */
    public static int[] intersection (int[] a, int[] b) {
        int [] intersec;
        if (!increasing(a) || !increasing(b))
            return new int[]{0, 0, 0, 0};

        int count = 0;
        for (int i = 0; i < a.length ; i++) {
            if (contains(b,a[i]))
                count++;
        }

        if(count == 0)
            return new int[]{0, 0, 0, 0};

        intersec = new int[count];
        count = 0;
        for (int i = 0; i < a.length ; i++) {
            if (contains(b,a[i])) {
                intersec[count] = a[i];
                count++;
            }

        }

        return intersec;
    }
```


----------



## BillyFitt (25. Nov 2016)

Hi, 
erstmal vielen Dank für deine Hilfe!
Ja, ich muss einfach die Prozeduren gemäß meiner Spezifikation implementieren, und dann muss ich noch die JUnit Tests verwenden, um meine Implementierung zu testen.

Die Tests sehen so aus:

```
import org.junit.Test;
import static org.junit.Assert.*;

public class IntersectionTests {

  // Tests fuer contains
  @Test
  public void containsTestIn() {
    int[] ar = {1,2,3,4};
    assertEquals(true, Intersection.contains(ar, 1));
    assertEquals(true, Intersection.contains(ar, 2));
    assertEquals(true, Intersection.contains(ar, 3));
    assertEquals(true, Intersection.contains(ar, 4));
  }

  @Test
  public void containsTestOut() {
    int[] ar = {2, 3, 4};
    assertEquals(false, Intersection.contains(ar, 1));
    assertEquals(false, Intersection.contains(ar, 5));
  }

  @Test
  public void containsCorner() {
    assertEquals(false, Intersection.contains(new int[]{}, 0));
  }

  // Tests fuer increasing
  @Test
  public void increasingTestIn() {
    assertEquals(true, Intersection.increasing(new int[] {1,2,3,4}));
    assertEquals(true, Intersection.increasing(new int[] {1, 10, 100}));
    assertEquals(true, Intersection.increasing(new int[] {42}));
  }

  @Test
  public void increasingTestOut() {
    assertEquals(false, Intersection.increasing(new int[] {4,3,2,1}));
    assertEquals(false, Intersection.increasing(new int[] {1,3,2,4}));
    assertEquals(false, Intersection.increasing(new int[] {42, 13}));
  }

  @Test
  public void increasingTestCorner() {
    assertEquals(true, Intersection.increasing(new int[] {}));
  }

  // Tests fuer intersection
  @Test
  public void intersectionTest1() {
    int[] ar1 = {1,2,3,4};
    int[] ar2 = {2,3,4,5};
    assertArrayEquals(new int[]{2,3,4}, Intersection.intersection(ar1, ar2));
  }

  @Test
  public void intersectionTest2() {
    int[] ar1 = {1,2,3};
    int[] ar2 = {4,5,6};
    assertArrayEquals(new int[]{}, Intersection.intersection(ar1, ar2));
  }

  @Test
  public void intersectionTest3() {
    int[] ar1 = {1,2,3};
    int[] ar2 = {1,2,3};
    assertArrayEquals(new int[]{1,2,3}, Intersection.intersection(ar1, ar2));
  }

  @Test
  public void intersectionTest4() {
    int[] ar1 = {42};
    int[] ar2 = {};
    assertArrayEquals(new int[]{}, Intersection.intersection(ar1, ar2));
  }

  @Test
  public void intersectionTest5() {
    int[] ar1 = {};
    int[] ar2 = {42};
    assertArrayEquals(new int[]{}, Intersection.intersection(ar1, ar2));
  }

  @Test
  public void intersectionTest6() {
    int[] ar1 = {};
    int[] ar2 = {};
    assertArrayEquals(new int[]{}, Intersection.intersection(ar1, ar2));
  }
}
```


----------

