An array A consisting of N integers is given. It contains daily prices of a stock share for a period of N consecutive days. If a single share was bought on day P and sold on day Q, where 0 ≤ P ≤ Q < N, then the profit of such transaction is equal to A[Q] − A[P], provided that A[Q] ≥ A[P]. Otherwise, the transaction brings loss of A[P] − A[Q].
For example, consider the following array A consisting of six elements such that:
A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367If a share was bought on day 0 and sold on day 2, a loss of 2048 would occur because A[2] − A[0] = 21123 − 23171 = −2048. If a share was bought on day 4 and sold on day 5, a profit of 354 would occur because A[5] − A[4] = 21367 − 21013 = 354. Maximum possible profit was 356. It would occur if a share was bought on day 1 and sold on day 5.
Write a function,
class Solution { public int solution(int[] A); }
that, given an array A consisting of N integers containing daily prices of a stock share for a period of N consecutive days, returns the maximum possible profit from one transaction during this period. The function should return 0 if it was impossible to gain any profit.
For example, given array A consisting of six elements such that:
A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367the function should return 356, as explained above.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [0..400,000];
- each element of array A is an integer within the range [0..200,000].
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
for(int i =0 ; i < A.length)
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int length = 0;
int result = 0;
int sum = 0;
for (int i = 0; i < length; i++) {
sum = 0;
for (int j = i; j < length; j++) {
sum += A[j];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int length = 0;
int result = 0;
int sum = 0;
for (int i = 0; i < length; i++) {
sum = 0;
for (int j = i; j < length; j++) {
sum += A[j];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int length = 0;
int result = 0;
int sum = 0;
for (int i = 0; i < length; i++) {
sum = 0;
for (int j = i; j < length; j++) {
sum += A[j];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int length = A.length;
int result = 0;
int sum = 0;
for (int i = 0; i < length; i++) {
sum = 0;
for (int j = i; j < length; j++) {
sum += A[j];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int length = A.length;
int result = 0;
int sum = 0;
for (int i = 0; i < length; i++) {
sum = 0;
for (int j = i; j < length; j++) {
sum += A[j];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int result = 0;
int sum = 0;
for (int i = 0; i < A.length; i++) {
sum = 0;
for (int j = i; j < A.length; j++) {
sum += A[j];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int result = 0;
int sum = 0;
for (int i = 0; i < A.length; i++) {
sum = 0;
for (int j = i; j < A.length; j++) {
sum += A[j];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int result = 0;
int sum = 0;
for (int i = 0; i < A.length; i++) {
for (int j = i + 1; j < A.length; j++) {
sum = A[j] - A[i];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int result = 0;
int sum = 0;
for (int i = 0; i < A.length; i++) {
for (int j = i + 1; j < A.length; j++) {
sum = A[j] - A[i];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int result = 0;
int sum = 0;
for (int i = 0; i < A.length; i++) {
for (int j = i + 1; j < A.length; j++) {
sum = A[j] - A[i];
result = Math.max(result, sum);
}
}
return result;
}
}
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
int result = 0;
int sum = 0;
for (int i = 0; i < A.length; i++) {
for (int j = i + 1; j < A.length; j++) {
sum = A[j] - A[i];
result = Math.max(result, sum);
}
}
return result;
}
}
The following issues have been detected: timeout errors.
max profit is after global maximum and before global minimum
large value (99) followed by short V-pattern (values from [1..5]) repeated 100 times
large value (99) followed by short pattern (values from [1..6]) repeated 10K times
Killed. Hard limit reached: 6.000 sec.
chaotic sequence of 200K values from [100K..120K], then 200K values from [0..100K]
Killed. Hard limit reached: 10.000 sec.
chaotic sequence of 200K values from [1..200K]
Killed. Hard limit reached: 8.000 sec.