Prefix Sums-CountDiv

Here is another codility problem solution from the codility lessons (CountDiv-Compute number of integers divisible by k in range [a..b].) due to the copy rights I can't copy the content of the problem here so to view the problem description click here.

class Solution {
	public int solution(int A, int B, int K) {
		// write your code in Java SE 8
		int count = 0;
		int div1 = 0;
		int div2 = 0;

		div1 = A / K;
		div2 = B / K;
		count = div2 - div1;
		if (A % K == 0) count++;

		return count;
	}
}

Prefix Sums - MinAvgTwoSlice

Here is another codility problem solution from the codility lessons (MinAvgTwoSlice-Find the minimal average of any slice containing at least two elements.) due to the copy rights I can't copy the content of the problem here so to view the problem description click here.

class Solution {
	public int solution(int[] A) {
		long min = Long.MAX_VALUE;
		int index = -1;
		//we have A+B/2 to be comapred with A+B+C/3
		//to make things easiler we are going to multuply both side with 6


		for (int i = 0; i < A.length - 2; i++) {

			long res1 = ((A[i] + A[i + 1])) * 3;
			long res2 = ((A[i] + A[i + 1] + A[i + 2])) * 2;



			long minRes = Math.min(res1, res2);

			if (minRes < min) {
				min = minRes;
				index = i;
			}

		}
		if ((A[A.length - 2] + A[A.length - 1]) * 3 < min) {
			return A.length - 2;
		}

		return index;
	}
}

Stacks and Queues - Fish

Here is another codility problem solution from the codility lessons (Fish-N voracious fish are moving along a river. Calculate how many fish are alive.) due to the copy rights I can't copy the content of the problem here so to view the problem description click here.

// you can also use imports, for example:
import java.util.*;

// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
	public int solution(int[] A, int[] B) {

		int count = 0;
		Stack < Integer > previousFishes = new Stack < Integer > ();

		for (int i = 0; i < A.length; i++) {
			int currentFish = A[i];
			int currentFlow = B[i];
			if (currentFlow == 1) {
				previousFishes.push(currentFish);
			}
			if (!previousFishes.empty() && currentFlow == 0) {
				while (!previousFishes.empty() && currentFish > previousFishes.peek()) {
					int fish = previousFishes.pop();
				}
			}
			if (previousFishes.empty() && currentFlow == 0) {
				count++;
			}

		}
		return count + previousFishes.size();
	}
}

Stacks and Queues - Nesting

Here is another codility problem solution from the codility lessons (Nesting -Determine whether given string of parentheses is properly nested.) due to the copy rights I can't copy the content of the problem here so to view the problem description click here.

// you can also use imports, for example:
import java.util.*;

// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
	public int solution(String S) {
		// write your code in Java SE 8
		if (S.length() % 2 != 0) return 0;
		if (S.length() == 0) return 1;



		Stack < Character > st = new Stack < Character > ();
		for (int i = 0; i < S.length(); i++) {

			if (isOpenTag(S.charAt(i))) {
				st.add(S.charAt(i));
			} else {
				if (!st.empty()) {
					char sc = st.pop();
					if (getCloseTag(sc) != S.charAt(i)) return 0;
				} else {
					return 0;
				}
			}

		}
		if (!st.empty()) return 0;

		return 1;


	}

	private char getCloseTag(char c) {
		switch (c) {
			case ('('):
				return ')';
			default:
				return ' ';

		}
	}

	private boolean isOpenTag(char c) {
		switch (c) {
			case ('('):
				return true;


			default:
				return false;

		}
	}

}

Maximum slice problem - MaxDoubleSliceSum

Here is another codility problem solution from the codility lessons (MaxDoubleSliceSum -Find the maximal sum of any double slice.) due to the copy rights I can't copy the content of the problem here so to view the problem description click here.

// you can also use imports, for example:
import java.util.*;

// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
	public int solution(int[] A) {
		int[] fromLiftDoubleSlices = new int[A.length];
		int[] fromRightDoubleSlices = new int[A.length];
		int max_ending = 0;
		for (int i = 1; i < A.length - 1; i++) {
			max_ending = Math.max(0, max_ending + A[i]);
			fromLiftDoubleSlices[i] = max_ending;
		}
		max_ending = 0;
		for (int i = A.length - 2; i > 0; i--) {
			max_ending = Math.max(0, max_ending + A[i]);
			fromRightDoubleSlices[i] = max_ending;
		}
		int maxSum = 0;
		for (int i = 1; i < A.length - 1; i++) {
			maxSum = Math.max(maxSum, fromLiftDoubleSlices[i - 1] + fromRightDoubleSlices[i + 1]);
		}



		return maxSum;
	}
}

Maximum slice problem - MaxSliceSum

Here is another codility problem solution from the codility lessons (MaxSliceSum - Find a maximum sum of a compact subsequence of array elements. ) due to the copy rights I can't copy the content of the problem here so to view the problem description click here.

Please be aware that the following code scores 92% only failed in on test case so if you could find where is the bug I will be glade to tell me.

class Solution {
	public int solution(int[] A) {
		// write your code in Java SE 8
		int sum = 0;
		int maxPosSeries = Integer.MIN_VALUE;
		int sumPos = 0;
		int maxVal = Integer.MIN_VALUE;
		boolean isPosFound = false;
		boolean containsPos = false;
		for (int i = 0; i < A.length; i++) {
			sum += A[i];
			maxVal = Math.max(maxVal, A[i]);
			if (A[i] >= 0) {
				isPosFound = true;
				containsPos = true;
				sumPos += A[i];
				maxPosSeries = Math.max(sumPos, maxPosSeries);

			} else if (A[i] < 0) {
				sumPos = 0;
				isPosFound = false;
			}


		}
		int min = Integer.MAX_VALUE;
		int ans = 0;
		int commulativeSUm = 0;

		for (int i = 0; i < A.length; i++) {
			commulativeSUm += A[i];
			int def = sum - (commulativeSUm);
			if (def < min) {
				min = def;
				ans = commulativeSUm;
			}

		}
		if (!containsPos) return maxVal;
		return Math.max(ans, maxPosSeries);

	}
}

Maximum slice problem - MaxProfit

Here is another codility problem solution from the codility lessons (MaxProfit -Given a log of stock prices compute the maximum possible earning. ) due to the copy rights I can't copy the content of the problem here so to view the problem description click here.

class Solution {
	public int solution(int[] A) {
		// write your code in Java SE 8

		int max = 0;
		int min = Integer.MAX_VALUE;
		int profit = Integer.MIN_VALUE;
		if (A.length < 2) return 0;
		for (int i = 0; i < A.length; i++) {

			min = Math.min(min, A[i]);
			int def = A[i] - min;
			profit = Math.max(profit, def);


		}

		return Math.abs(profit);
	}
}