You are given N counters, initially set to 0, and you have two possible operations on them:
- increase(X) − counter X is increased by 1,
- max counter − all counters are set to the maximum value of any counter.
A non-empty array A of M integers is given. This array represents consecutive operations:
- if A[K] = X, such that 1 ≤ X ≤ N, then operation K is increase(X),
- if A[K] = N + 1 then operation K is max counter.
For example, given integer N = 5 and array A such that:
A[0] = 3 A[1] = 4 A[2] = 4 A[3] = 6 A[4] = 1 A[5] = 4 A[6] = 4the values of the counters after each consecutive operation will be:
(0, 0, 1, 0, 0) (0, 0, 1, 1, 0) (0, 0, 1, 2, 0) (2, 2, 2, 2, 2) (3, 2, 2, 2, 2) (3, 2, 2, 3, 2) (3, 2, 2, 4, 2)The goal is to calculate the value of every counter after all operations.
Write a function:
class Solution { public int[] solution(int N, int[] A); }
that, given an integer N and a non-empty array A consisting of M integers, returns a sequence of integers representing the values of the counters.
Result array should be returned as an array of integers.
For example, given:
A[0] = 3 A[1] = 4 A[2] = 4 A[3] = 6 A[4] = 1 A[5] = 4 A[6] = 4the function should return [3, 2, 2, 4, 2], as explained above.
Write an efficient algorithm for the following assumptions:
- N and M are integers within the range [1..100,000];
- each element of array A is an integer within the range [1..N + 1].
// 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 N, int[] A) {
int[] result = new int[N];
int max = 0;
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
for (int num : A) {
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
for (int num : A) {
if ()
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
for (int num : A) {
if (num == N + 1) { // Max is N + 1
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
for (int num : A) {
if (num == N + 1) { // Maximum number is N + 1.
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Maximum number is N + 1.
init = max;
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Maximum number is N + 1.
init = max;
} else {
if (init > result[num - 1])
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Maximum number is N + 1.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Maximum number is N + 1.
// Over than
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size.
// Maximum number is N + 1
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size, Maximum number is N + 1
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size, Maximum number is N + 1
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Change value to max counter.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Change init value to max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) { // Lower than init value.
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
// Save maximum value.
if (result[num - 1] > max) {
max = result[num - 1];
}
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
// Save maximum value.
if (result[num - 1] > max) {
max = result[num - 1];
}
}
}
// If lower than init value, change each values.
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
// Save maximum value.
if (result[num - 1] > max) {
max = result[num - 1];
}
}
}
// If lower than init value, change each values.
for (int idx = 0; idx < result.length; idx++) {
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
// Save maximum value.
if (result[num - 1] > max) {
max = result[num - 1];
}
}
}
// If lower than init value, change each values.
for (int idx = 0; idx < N; idx++) {
if ()
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
// Save maximum value.
if (result[num - 1] > max) {
max = result[num - 1];
}
}
}
// If lower than init value, change each values.
for (int idx = 0; idx < N; idx++) {
if
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
// Save maximum value.
if (result[num - 1] > max) {
max = result[num - 1];
}
}
}
// If lower than init value, change each values.
for (int idx = 0; idx < N; idx++) {
if (result[idx] < init) {
result[idx] = init;
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
// Save maximum value.
if (result[num - 1] > max) {
max = result[num - 1];
}
}
}
// If lower than init value, change each values.
for (int idx = 0; idx < N; idx++) {
if (result[idx] < init) {
result[idx] = init;
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
// Save maximum value.
if (result[num - 1] > max) {
max = result[num - 1];
}
}
}
// If lower than init value, change each values.
for (int idx = 0; idx < N; idx++) {
if (result[idx] < init) {
result[idx] = init;
}
}
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 N, int[] A) {
int[] result = new int[N];
int max = 0;
int init = 0;
for (int num : A) {
if (num == N + 1) { // Over than array size and maximum number is N + 1
// Set init value using max value.
init = max;
} else {
if (init > result[num - 1]) {
result[num - 1] = init + 1;
} else {
result[num - 1]++;
}
// Save maximum value.
if (result[num - 1] > max) {
max = result[num - 1];
}
}
}
// If lower than init value, change each values.
for (int idx = 0; idx < N; idx++) {
if (result[idx] < init) {
result[idx] = init;
}
}
return result;
}
}
The solution obtained perfect score.