MaxProfit coding task - Learn to Code

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

int solution(int A[], int N);

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

int solution(vector<int> &A);

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

int solution(vector<int> &A);

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

class Solution { public int solution(int[] A); }

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

int solution(List<int> A);

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

func Solution(A []int) int

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

class Solution { public int solution(int[] A); }

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

class Solution { public int solution(int[] A); }

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

function solution(A);

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

fun solution(A: IntArray): Int

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

function solution(A)

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

int solution(NSMutableArray *A);

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

function solution(A: array of longint; N: longint): longint;

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

function solution($A);

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

sub solution { my (@A) = @_; ... }

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

def solution(A)

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

def solution(a)

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

object Solution { def solution(a: Array[Int]): Int }

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

public func solution(_ A : inout [Int]) -> Int

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

function solution(A: number[]): number;

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

一个包含N个元素的数组A, 每个元素表示公司股票的每日价格(美分).

写一个函数

Private Function solution(A As Integer()) As Integer

返回在这段时间内每份额可能获得的最大收益(美分). 如果不能获得任何收益,则返回零. 准确的说,函数应返回

max{0, A[m]−A[k] : 0 ≤ k < m < N }

例如: 指定 N=6,

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

函数应返回356: 在股票价格为210.11美元时买进, 而在213.67.美元时卖出, 则获得最大收益为3.56美元. 假设数组A可能包含上百兆字节.

假定:

N 是 [0..400,000] 内的整数;

数组 A 每个元素是取值范围 [0..200,000] 内的整数 .

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] = 21367

If 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,

int solution(int A[], int N);

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] = 21367

the 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].

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] = 21367

If 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,

int solution(vector<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] = 21367

the 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].

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] = 21367

If 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,

int solution(vector<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] = 21367

the 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].

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] = 21367

If 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] = 21367

the 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].

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] = 21367

If 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,

int solution(List<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] = 21367

the 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].

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] = 21367

If 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,

func Solution(A []int) int

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] = 21367

the 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].

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] = 21367

If 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] = 21367

the 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].

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] = 21367

If 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] = 21367

the 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].

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] = 21367

If 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,

function solution(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] = 21367

the 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].

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] = 21367

If 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,

fun solution(A: IntArray): Int

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] = 21367

the 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].

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] = 21367

If 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,

function solution(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] = 21367

the 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].

Note: All arrays in this task are zero-indexed, unlike the common Lua convention. You can use #A to get the length of the array A.

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] = 21367

If 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,

int solution(NSMutableArray *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] = 21367

the 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].

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] = 21367

If 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,

function solution(A: array of longint; N: longint): longint;

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] = 21367

the 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].

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] = 21367

If 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,

function solution($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] = 21367

the 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].

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] = 21367

If 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,

sub solution { my (@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] = 21367

the 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].

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] = 21367

If 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,

def solution(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] = 21367

the 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].

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] = 21367

If 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,

def solution(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] = 21367

the 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].

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] = 21367

If 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,

object Solution { def solution(a: Array[Int]): Int }

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] = 21367

the 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].

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] = 21367

If 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,

public func solution(_ A : inout [Int]) -> Int

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] = 21367

the 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].

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] = 21367

If 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,

function solution(A: number[]): number;

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] = 21367

the 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].

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] = 21367

If 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,

Private Function solution(A As Integer()) As Integer

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] = 21367

the 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].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

int solution(int A[], int N);

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

int solution(vector<int> &A);

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

int solution(vector<int> &A);

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

class Solution { public int solution(int[] A); }

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

int solution(List<int> A);

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

func Solution(A []int) int

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

class Solution { public int solution(int[] A); }

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

class Solution { public int solution(int[] A); }

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

function solution(A);

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

fun solution(A: IntArray): Int

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

function solution(A)

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

int solution(NSMutableArray *A);

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

function solution(A: array of longint; N: longint): longint;

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

function solution($A);

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

sub solution { my (@A) = @_; ... }

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

def solution(A)

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

def solution(a)

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

object Solution { def solution(a: Array[Int]): Int }

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

public func solution(_ A : inout [Int]) -> Int

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

function solution(A: number[]): number;

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

Dana jest tablica A (indeksowana od zera) zawierająca N liczb całkowitych. Są to ceny akcji pewnej spółki notowanej na giełdzie, ustalane każdego dnia przez N kolejnych dni. Jeżeli kupimy pojedynczą akcję w dniu P i sprzedamy ją w dniu Q, dla 0 ≤ P ≤ Q < N, to nasz zysk będzie wynosił A[Q] − A[P], zakładając że A[Q] ≥ A[P]. W przeciwnym przypadku, poniesiemy stratę wysokości A[P] − A[Q].

Rozważmy na przykład następującą tablicę A zawierającą sześć liczb:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

Gdybyśmy kupili pojedynczą akcję w dniu 0 i sprzedali ją w dniu 2, ponieślibyśmy stratę wysokości 2048, ponieważ A[2] − A[0] = 21123 − 23171 = −2048. Gdybyśmy natomiast kupili pojedynczą akcję w dniu 4 i sprzedali ją w dniu 5 nasz zysk wyniósłby 354, ponieważ A[5] − A[4] = 21367 − 21013 = 354. Maksymalny możliwy zysk wynosi 356. Ma on miejsce jeżeli kupimy akcję w dniu 1 i sprzedamy w dniu 5.

Napisz funkcję:

Private Function solution(A As Integer()) As Integer

która, mając daną (indeksowaną od zera) tablicę A zawierającą N liczb całkowitych będących akcjami pewnej spółki notowanej na giełdzie, ustalanymi każdego dnia przez N kolejnych dni, zwróci maksymalny możliwy zysk na jednokrotnym kupnie i sprzedaży pojedynczej akcji. Funkcja powinna zwrócić 0 jeżeli zysk nie jest możliwy.

Na przykład, mając daną następującą tablicę A:

A[0] = 23171 A[1] = 21011 A[2] = 21123 A[3] = 21366 A[4] = 21013 A[5] = 21367

funkcja powinna zwrócić 356, jak to wyjaśniono powyżej.

Założenia:

N to liczba całkowita z przedziału [0..400,000];

każdy element tablicy A to liczba całkowita z przedziału [0..200,000].

MaxProfit

Developer Training

Sign up for our newsletter:

Social: