天天渴望阳光的微笑# Piebridge - 鹊桥
c*t
1 楼
纠结它只让改三行code, 毫无头绪，求解
Consider N coins aligned in a row. Each coin is showing either heads or
tails. The adjacency of these coins is the number of adjacent pairs of coins
with the same side of face.
You are giving an implementation of a function:
int solution(int A[], int N);
that, given a non-empty zero-idexed array A consisting of N integers
representing the coins, returns the maximum possible adjacency that can be
obtained by reversing exactly one coin (that is, one of the coins must be
reversed). Consecutive elements of array A represent consecutive coins in
the row. Array A contains only 0s and/or 1s:
0 represents a coin with heads facing up;
1 represents a coin with tails facing up.
For example, given array A consisting of six numbers, such that:
A[0] = 1
A[1] = 1
A[2] = 0
A[3] = 1
A[4] = 0
A[5] = 0
the function should return 4. The initial adjacency is 2, as there are
two pairs of adjacent coins with the same side facing up, namely (0, 1) and
(4, 5). After reversing the coin represented by A[2], the adjacency equals 4
, as there are four pairs of adjacent coins with the same side facing up,
namely: (0, 1), (1, 2), (2, 3) and (4, 5), and it is not possible to obtain
a higher adjacency.
Unfortunately, despite the fact that the funciton may return expected
result for hte example input, there is a bug in the implementation, which
may produce incorrect results for other inputs. Find the bug and correct it.
You should modify at most three lines of code.
N is an integer within the range of [1....1'000]. And it has to be done
as O(N) time and O(1) space. Elements of input arrays can be modified.
int solution(int *A, int A_length) {
int n = A_length;
int result = 0;
int i;
for (i = 0; i < n - 1; i++) {
if (A[i] == A[i + 1])
result = result + 1;
}
int r = 0;
for (i = 0; i < n; i++) {
int count = 0;
if (i > 0) {
if (A[i - 1] != A[i])
count = count + 1;
else
count = count - 1;
}
if (i < n - 1) {
if (A[i + 1] != A[i])
count = count + 1;
else
count = count - 1;
}
if (count > r)
r = count;
}
return result + r;
}
Consider N coins aligned in a row. Each coin is showing either heads or
tails. The adjacency of these coins is the number of adjacent pairs of coins
with the same side of face.
You are giving an implementation of a function:
int solution(int A[], int N);
that, given a non-empty zero-idexed array A consisting of N integers
representing the coins, returns the maximum possible adjacency that can be
obtained by reversing exactly one coin (that is, one of the coins must be
reversed). Consecutive elements of array A represent consecutive coins in
the row. Array A contains only 0s and/or 1s:
0 represents a coin with heads facing up;
1 represents a coin with tails facing up.
For example, given array A consisting of six numbers, such that:
A[0] = 1
A[1] = 1
A[2] = 0
A[3] = 1
A[4] = 0
A[5] = 0
the function should return 4. The initial adjacency is 2, as there are
two pairs of adjacent coins with the same side facing up, namely (0, 1) and
(4, 5). After reversing the coin represented by A[2], the adjacency equals 4
, as there are four pairs of adjacent coins with the same side facing up,
namely: (0, 1), (1, 2), (2, 3) and (4, 5), and it is not possible to obtain
a higher adjacency.
Unfortunately, despite the fact that the funciton may return expected
result for hte example input, there is a bug in the implementation, which
may produce incorrect results for other inputs. Find the bug and correct it.
You should modify at most three lines of code.
N is an integer within the range of [1....1'000]. And it has to be done
as O(N) time and O(1) space. Elements of input arrays can be modified.
int solution(int *A, int A_length) {
int n = A_length;
int result = 0;
int i;
for (i = 0; i < n - 1; i++) {
if (A[i] == A[i + 1])
result = result + 1;
}
int r = 0;
for (i = 0; i < n; i++) {
int count = 0;
if (i > 0) {
if (A[i - 1] != A[i])
count = count + 1;
else
count = count - 1;
}
if (i < n - 1) {
if (A[i + 1] != A[i])
count = count + 1;
else
count = count - 1;
}
if (count > r)
r = count;
}
return result + r;
}