For example, if the array windSpeed contains the values {82, 70, 12} and the array windDirection contains the values {12, 266, 92}, the output to the screen should be:

Wind speed 82 km/h and wind direction 12°, Wind speed 70 km/h and wind direction 266°, Wind speed 12 km/h and wind direction 92°

Write a method int count5PercentJumps(int[]) that returns the number of sales jumps. A sales jump is given if the sales were 5% higher than the previous day.

The passed array must not be null, or an exception will be thrown.

Write a new method isProbablyApproaching(String[] signs) that returns true if there are four of the same abbreviation in the array consecutively in a row. Remember that strings are compared using equals(…​).

The array passed must not be null, and no element in the array must be null.

Write a new static method reverse(…​) that flips a given array:

public static void reverse( double[] numbers ) {
  // TODO
}

The operation should be in place, that is, it should change the array passed. We do not want to create a new array inside the method reverse(…​).

An exception will be thrown if null is passed.

{ } → { }

{ 1 } → { 1 }

{ 1, 2 } → { 2, 1 }

{ 1, 2, 3 } → { 3, 2, 1 }

Given a set of Point objects in an array points for the cinema positions.

Point[] points = { new Point(10, 20), new Point(12, 2), new Point(44, 4) };

Write a method double minDistance(Point[] points, int size) that returns the distance of the point that has the smallest distance to the zero point. With size we can specify how many array elements should be considered, allowing the array to be larger in theory.

A passed null is not allowed, also the points themselves must not be null; an exception must be raised.

What should we change if the return type is Point, implying that the point itself should be returned with the shortest distance?

Write a method int findSplitPoint(int[]) that finds the index in the array where left and right can be fairly split. Any solution will do, not all solutions are necessary.

A method must return -1 if there is no fair split.

10 + 20 + 30 + 40 ≈ 40 + 50 because 100 ≈ 90, and the index for the return is 4.

10 20 30 40 100 results in -1 because there is no valid partitioning.

Write a method int[] shuffleDice() that returns an int array with 5 random numbers that are between 1 and 6.

Write a method isHomogeneous(int[] values) that tests if all values in the array are equal. (The word homogeneous means uniform/similar/equal). In principle, the array may be of any size.

Write a method int[] occurrences(int[] values), which returns a new array of size 6, which indicates which number occurs how often.

Write a method isFullHouse(int[] values) that checks if three dice have the same value and two other dice have a different same value. For example, {1, 1, 1, 2, 2} is such a case.

Write a method void printDiceValues(int[] points) that writes the dice numbers to the screen as follows:

isHomogeneous(new int[]{ 1, 1, 1, 1 }) returns true.

isHomogeneous( new int[]{ 1, 1, 1, 2, 2 } ) returns false.

occurrences( new int[]{ 1, 1, 2, 3, 4 }) returns an array with the values {2, 1, 1, 1, 0, 0}.

isFullHouse(new int[]{ 1, 1, 1, 2, 2 }) returns true.

isFullHouse(new int[]{ 1, 1, 1, 1 }) returns false.

printDiceValues(shuffleDice()) returns 2 × ⚁, 2 × ⚃, ⚅.

Write a program with a method printMountain(int[] altitudes) that converts an array of altitude meters into an ASCII representation.

The altitude has to be represented by a multiplication sign * at exactly this altitude from a baseline. The heights can be arbitrary, but not negative.

The array { 0, 1, 1, 2, 2, 3, 3, 3, 4, 5, 4, 3, 2, 2, 1, 0 } shall be represented as:

5          *
4         * *
3      ***   *
2    **       **
1  **           *
0 *              *

Instead of *, use the symbols /, \, -, and ^ to indicate whether we are ascending, descending, on a plateau, or at the top.

5          ^
4         / \
3      --/   \
2    -/       -\
1  -/           \
0 /              \

Write a program that tests a two-dimensional array of nine elements to see if all numbers from 1 to 9 occur.

Missing elements are to be reported.

The following array is a valid Sudoku assignment:

int[][] array = {
    { 1, 2, 3 },
    { 4, 5, 6 },
    { 7, 8, 9 }
};

The following array is not a valid Sudoku assignment:

int[][] array = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 8 } };

Given a two-dimensional integer array with values from 0 to 255; the array mentally represents a grayscale image.

Write a method int[][] magnify(int[][] array, int factor) that returns a new array and scales the image by the given factor. So, an image of size 2 × 3 and factor 2 becomes an image of size 4 × 6. Image pixels are simply doubled, no interpolation of values is desired.

Assume the following array:

{ {1, 2, 3},
  {4, 5, 6} }

{ {1, 1, 2, 2, 3, 3},
  {1, 1, 2, 2, 3, 3},
  {4, 4, 5, 5, 6, 6},
  {4, 4, 5, 5, 6, 6} }

Declare a Java method printSvgPolygon(…​) to which we can pass any number of coordinate pairs. What errors could occur when passing them?

The method should print a matching SVG output to the screen for the passed pairs.

In printSvgPolygon( 200, 10, 250, 190, 160, 210 ), 200,10 is a coordinate pair, 250,190 is as well, as is 160, 210. The screen output should be: <polygon points="200,10 250,190 160,210" />.

We are looking for a vararg method allTrue(…​) that can accept any number of boolean values, but must be called at least with one argument.

If all arguments are true, the return is also true; if one of the boolean values is false, the method shall return false.

Since a vararg is internally an array, null may be passed — this must lead to an exception.

allTrue(true, true, true) returns true.

allTrue(true) returns true.

allTrue(true, false) returns false.

allTrue(true, null) returns an exception.

allTrue() cannot be compiled and must give a compiler error.

Write a method fourLast(int... numbers) that places all numbers containing a 4 after the numbers that do not have a 4. The order of the numbers without 4 must not change, the numbers with a 4 can be anywhere at the end.

fourLast(…​) should return the passed array.

The argument null must lead to an exception.

int[] numbers = {1, 44, 2, 4, 43}; fourLast(numbers); modifies the array numbers so that 1 and 2 are before 44, 4 and 43 in the array. The 2 must not come before the 1 later.

fourLast( 4, 4, 44, 1234 ) returns the array automatically generated by the compiler with the entries, for example in the order 4, 4, 44, 1234.