Tasks Details
medium
Given N rectangular buildings of width 1, find the minimum total area of two rectangular banners that cover all of the buildings.
Task Score
50%
Correctness
100%
Performance
0%
There are N rectangular buildings standing along the road next to each other. The K-th building is of size H[K] × 1.
Because a renovation of all of the buildings is planned, we want to cover them with rectangular banners until the renovations are finished. Of course, to cover a building, the banner has to be at least as high as the building. We can cover more than one building with a banner if it is wider than 1.
For example, to cover buildings of heights 3, 1, 4 we could use a banner of size 4×3 (i.e. of height 4 and width 3), marked here in blue:
We can order at most two banners and we want to cover all of the buildings. Also, we want to minimize the amount of material needed to produce the banners.
What is the minimum total area of at most two banners which cover all of the buildings?
Write a function:
class Solution { public int solution(int[] H); }
that, given an array H consisting of N integers, returns the minimum total area of at most two banners that we will have to order.
Examples:
1. Given H = [3, 1, 4], the function should return 10. The result can be achieved by covering the first two buildings with a banner of size 3×2 and the third building with a banner of size 4×1:
2. Given H = [5, 3, 2, 4], the function should return 17. The result can be achieved by covering the first building with a banner of size 5×1 and the other buildings with a banner of size 4×3:
3. Given H = [5, 3, 5, 2, 1], your function should return 19. The result can be achieved by covering the first three buildings with a banner of size 5×3 and the other two with a banner of size 2×2:
4. Given H = [7, 7, 3, 7, 7], your function should return 35. The result can be achieved by using one banner of size 7×5:
5. Given H = [1, 1, 7, 6, 6, 6], your function should return 30. The result can be achieved by using banners of size 1×2 and 7×4:
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of array H is an integer within the range [1..10,000].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Java 11
Time spent on task 81 minutes
Notes
not defined yet
Code: 20:39:50 UTC,
java,
autosave
Code: 20:39:57 UTC,
java11,
autosave
Code: 20:48:38 UTC,
java11,
autosave
Code: 20:49:08 UTC,
java11,
autosave
Code: 20:49:18 UTC,
java11,
autosave
Code: 20:49:51 UTC,
java11,
autosave
Code: 20:50:05 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
}
}
Code: 20:50:26 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int wastedSpace = Arrays.stream(H).forEach
}
}
Code: 20:50:57 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int wastedSpace = 0;
for (int b : H) {
wastedSpace
}
}
}
Code: 20:51:09 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int wastedSpace = 0;
for (int b : H) {
wastedSpace += tallestBuilding - b;
}
}
}
Code: 20:51:19 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int wastedSpace = 0;
for (int b : H) {
wastedSpace += tallestBuilding - b;
}
}
}
Code: 20:52:46 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int empty = 0;
for (int b : H) {
wastedSpace += tallestBuilding - b;
}
}
}
Code: 20:52:56 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
}
}
Code: 20:55:25 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
}
}
Code: 20:55:44 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
}
}
Code: 21:12:31 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double
}
}
Code: 21:12:42 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).)
}
}
Code: 21:13:10 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average();
}
}
Code: 21:13:38 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
}
}
Code: 21:14:09 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
}
}
Code: 21:14:24 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
for (int i = 0; i < H.length)
}
}
Code: 21:14:54 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
for (int i = 0; i < H.length; i++) {
if (H[i])
}
}
}
Code: 21:15:25 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
for (int i = 0; i < H.length; i++) {
if (H[i] < avgHeight) {
break;
}
coverageLeft += H[i];
}
i
}
}
Code: 21:15:41 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
for (int i = 0; i < H.length; i++) {
if (H[i] < avgHeight) {
break;
}
coverageLeft += H[i];
}
// go from right
int coverageRight = 0;
for (int i = H.length)
}
}
Code: 21:16:12 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
for (int i = 0; i < H.length; i++) {
if (H[i] < avgHeight) {
break;
}
coverageLeft += H[i];
}
// go from right
int coverageRight = 0;
for (int i = H.length; i >= 0; i--) {
if ()
}
}
}
Code: 21:16:31 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
for (int i = 0; i < H.length; i++) {
if (H[i] < avgHeight) {
break;
}
coverageLeft += H[i];
}
// go from right
int coverageRight = 0;
for (int i = H.length; i >= 0; i--) {
if (H[i] < avgHeight) {
break;
}
coverageRight += H[i];
}
}
}
Code: 21:16:55 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[i] < avgHeight) {
break;
}
coverageLeft += H[i];
}
// go from right
int coverageRight = 0;
for (int i = H.length; i >= 0; i--) {
if (H[i] < avgHeight) {
break;
}
coverageRight += H[i];
}
}
}
Code: 21:17:10 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[i] < avgHeight) {
break;
}
coverageLeft += H[i];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; i--) {
if (H[i] < avgHeight) {
break;
}
coverageRight += H[i];
}
}
}
Code: 21:17:30 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
}
}
Code: 21:19:02 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if
}
}
Code: 21:19:29 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream().sum();
}
}
}
Code: 21:19:40 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
}
}
Code: 21:19:53 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
}
}
}
Code: 21:20:10 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
int remainingCoverage
}
}
}
Code: 21:20:21 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int )
}
}
}
Code: 21:20:36 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage +=
}
}
}
}
Code: 21:20:56 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
}
}
Code: 21:21:08 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
}
}
Code: 21:21:39 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
int remainingCoverage = 0;
int adjustment = coverageLeft > coverageRight ? 1
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
}
}
Code: 21:22:09 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
int remainingCoverage = 0;
int adjustment = coverageLeft > coverageRight ? 1 : -1;
int startPos = coverageLeft > coverageRight ? leftBound : rightBound;
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
}
}
Code: 21:22:20 UTC,
java11,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
int remainingCoverage = 0;
int adjustment = coverageLeft > coverageRight ? 1 : -1;
int startPos = coverageLeft > coverageRight ? leftBound : rightBound;
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
}
}
Code: 21:22:51 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
for (int i = rightBound; i >= 0; i--) {
remainingCoverage += H[i];
}
return coverageRight + remainingCoverage;
}
}
Code: 21:22:55 UTC,
java11,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
for (int i = rightBound; i >= 0; i--) {
remainingCoverage += H[i];
}
return coverageRight + remainingCoverage;
}
}
Analysis
expand all
Example tests
1.
0.016 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3 at Solution.solution(Solution.java:36) at Exec.run(exec.java:48) at Exec.main(exec.java:34)
1.
0.016 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4 at Solution.solution(Solution.java:36) at Exec.run(exec.java:48) at Exec.main(exec.java:34)
1.
0.012 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5 at Solution.solution(Solution.java:36) at Exec.run(exec.java:48) at Exec.main(exec.java:34)
1.
0.016 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5 at Solution.solution(Solution.java:36) at Exec.run(exec.java:48) at Exec.main(exec.java:34)
1.
0.016 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 6 out of bounds for length 6 at Solution.solution(Solution.java:36) at Exec.run(exec.java:48) at Exec.main(exec.java:34)
Code: 21:23:23 UTC,
java11,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length ; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
for (int i = rightBound; i >= 0; i--) {
remainingCoverage += H[i];
}
return coverageRight + remainingCoverage;
}
}
Code: 21:23:34 UTC,
java11,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length - 1; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
for (int i = rightBound; i >= 0; i--) {
remainingCoverage += H[i];
}
return coverageRight + remainingCoverage;
}
}
Analysis
expand all
Example tests
1.
0.016 s
WRONG ANSWER,
got 8 expected 10
1.
0.016 s
WRONG ANSWER,
got 14 expected 17
1.
0.016 s
WRONG ANSWER,
got 16 expected 19
1.
0.016 s
WRONG ANSWER,
got 31 expected 35
1.
0.016 s
WRONG ANSWER,
got 27 expected 30
Code: 21:24:37 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length - 1; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
syst
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
for (int i = rightBound; i >= 0; i--) {
remainingCoverage += H[i];
}
return coverageRight + remainingCoverage;
}
}
Code: 21:24:51 UTC,
java11,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// go from left
int coverageLeft = 0;
int leftBound;
for (leftBound = 0; leftBound < H.length; leftBound++) {
if (H[leftBound] < avgHeight) {
break;
}
coverageLeft += H[leftBound];
}
// go from right
int coverageRight = 0;
int rightBound;
for (rightBound = H.length - 1; rightBound >= 0; rightBound--) {
if (H[rightBound] < avgHeight) {
break;
}
coverageRight += H[rightBound];
}
if (coverageLeft == coverageRight && leftBound == rightBound) {
return Arrays.stream(H).sum();
}
System.out.println(coverageLeft + " : " + coverageRight);
if (coverageLeft > coverageRight) {
int remainingCoverage = 0;
for (int i = leftBound; i < H.length; i++) {
remainingCoverage += H[i];
}
return coverageLeft + remainingCoverage;
}
int remainingCoverage = 0;
for (int i = rightBound; i >= 0; i--) {
remainingCoverage += H[i];
}
return coverageRight + remainingCoverage;
}
}
Analysis
expand all
Example tests
1.
0.044 s
WRONG ANSWER,
got 8 expected 10
stdout:
3 : 4
1.
0.044 s
WRONG ANSWER,
got 14 expected 17
stdout:
5 : 4
1.
0.044 s
WRONG ANSWER,
got 16 expected 19
stdout:
5 : 0
1.
0.016 s
WRONG ANSWER,
got 31 expected 35
1.
0.044 s
WRONG ANSWER,
got 27 expected 30
stdout:
0 : 25
Code: 21:30:24 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
}
}
Code: 21:30:41 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound = H.length;
}
}
Code: 21:31:11 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
for (bound = H.length - 1; bound >= 0; )
}
}
Code: 21:31:22 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int minWastedSpace
for (bound = H.length - 1; bound >= 0; bound--) {
}
}
}
Code: 21:31:46 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
}
}
}
Code: 21:32:14 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
for (int left = 0; left <= bound; left++) {
}
}
}
}
Code: 21:32:44 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left])
}
}
}
}
Code: 21:33:06 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage +=
}
}
}
}
Code: 21:33:17 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
leftEmpty
}
}
}
}
Code: 21:33:36 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
}
}
}
Code: 21:33:46 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
}
}
}
Code: 21:35:09 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
}
}
}
Code: 21:35:20 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
}
}
}
Code: 21:35:56 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
}
}
}
Code: 21:36:14 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
leftEmpty = Arrays.copyOfRange(H, 0, bound).stream()
}
}
}
Code: 21:36:24 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
leftEmpty = Arrays.stream(Arrays.copyOfRange(H, 0, bound)).
}
}
}
Code: 21:36:55 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty
}
}
}
}
Code: 21:37:07 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
}
}
}
Code: 21:38:11 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
}
}
}
Code: 21:38:25 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight = 0;
}
}
}
Code: 21:38:43 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft = 0;
int leftCoverage = 0;
int leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
}
}
}
Code: 21:39:13 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
}
}
}
Code: 21:39:36 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
}
}
}
}
Code: 21:39:58 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
}
}
}
}
Code: 21:40:08 UTC,
java11,
autosave
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
}
}
}
}
Code: 21:40:39 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
if )
}
}
}
}
Code: 21:40:54 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
}
}
}
Code: 21:41:24 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
}
}
}
Code: 21:41:35 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
}
}
Code: 21:41:48 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
for ()
}
}
Code: 21:42:06 UTC,
java11,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
for (int left = 0; left <= optimalBound; left++) {
}
}
}
Code: 21:42:36 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound)
}
}
Code: 21:42:57 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
}
}
Code: 21:43:47 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound +);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
}
}
Code: 21:43:57 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
}
}
Code: 21:44:23 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max() * leftBanner.length)
}
}
Code: 21:44:53 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max() * leftBanner.length)
+ (Arrays.stream(rightBanner).max() * rightBanner.length);
return bannerS
}
}
Code: 21:45:03 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max() * leftBanner.length)
+ (Arrays.stream(rightBanner).max() * rightBanner.length);
return bannerSize;
}
}
Code: 21:45:05 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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[] H) {
// int totalBuildingsArea = Arrays.stream(H).sum();
// int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max() * leftBanner.length)
+ (Arrays.stream(rightBanner).max() * rightBanner.length);
return bannerSize;
}
}
Analysis
Compile error
Solution.java:16: error: cannot find symbol
emptySpace += tallestBuilding - b;
^
symbol: variable tallestBuilding
location: class Solution
Solution.java:62: error: bad operand types for binary operator '*'
int bannerSize = (Arrays.stream(leftBanner).max() * leftBanner.length)
^
first type: OptionalInt
second type: int
Solution.java:63: error: bad operand types for binary operator '*'
+ (Arrays.stream(rightBanner).max() * rightBanner.length);
^
first type: OptionalInt
second type: int
3 errors
Code: 21:45:17 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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[] H) {
// int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max() * leftBanner.length)
+ (Arrays.stream(rightBanner).max() * rightBanner.length);
return bannerSize;
}
}
Code: 21:45:18 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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[] H) {
// int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max() * leftBanner.length)
+ (Arrays.stream(rightBanner).max() * rightBanner.length);
return bannerSize;
}
}
Analysis
Compile error
Solution.java:62: error: bad operand types for binary operator '*'
int bannerSize = (Arrays.stream(leftBanner).max() * leftBanner.length)
^
first type: OptionalInt
second type: int
Solution.java:63: error: bad operand types for binary operator '*'
+ (Arrays.stream(rightBanner).max() * rightBanner.length);
^
first type: OptionalInt
second type: int
2 errors
Code: 21:45:39 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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[] H) {
// int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
expand all
Example tests
1.
0.004 s
WRONG ANSWER,
got 12 expected 10
1.
0.008 s
WRONG ANSWER,
got 20 expected 17
1.
0.008 s
WRONG ANSWER,
got 25 expected 19
1.
0.008 s
OK
1.
0.008 s
WRONG ANSWER,
got 42 expected 30
Code: 21:46:43 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:47:06 UTC,
java11,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = emptySpace;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((rightEmpty + leftEmpty) < emptySpace)
optimalbound = bound;
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:47:36 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpt + leftEmpty) < emptySpace) {
optimalbound = bound;
emptySpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:47:46 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < emptySpace) {
optimalbound = bound;
emptySpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:47:46 UTC,
java11,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < emptySpace) {
optimalbound = bound;
emptySpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
expand all
Example tests
1.
0.008 s
WRONG ANSWER,
got 12 expected 10
1.
0.008 s
WRONG ANSWER,
got 20 expected 17
1.
0.008 s
WRONG ANSWER,
got 25 expected 19
1.
0.008 s
OK
1.
0.008 s
WRONG ANSWER,
got 42 expected 30
Code: 21:48:35 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < emptySpace) {
optimalbound = bound;
emptySpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:48:58 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(leftEmpty + " : " + rightEmpty + " | " + )
if ((leftEmpty + rightEmpty) < emptySpace) {
optimalbound = bound;
emptySpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:49:13 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(leftEmpty + " : " + rightEmpty + " | " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
expand all
Example tests
1.
0.060 s
WRONG ANSWER,
got 12 expected 10
stdout:
4 : 0 | 12 2 : 0 | 4 0 : 3 | 2
1.
0.056 s
WRONG ANSWER,
got 20 expected 17
stdout:
6 : 0 | 20 5 : 0 | 6 2 : 2 | 5 0 : 3 | 4
1.
0.060 s
WRONG ANSWER,
got 25 expected 19
stdout:
9 : 0 | 25 5 : 0 | 9 2 : 1 | 5 2 : 7 | 3 0 : 9 | 3
1.
0.060 s
OK
stdout:
4 : 0 | 35 4 : 0 | 4 4 : 0 | 4 0 : 4 | 4 0 : 4 | 4
1.
0.060 s
WRONG ANSWER,
got 42 expected 30
stdout:
15 : 0 | 42 14 : 0 | 15 13 : 0 | 14 12 : 0 | 13 0 : 3 | 12 0 : 9 | 3
Code: 21:49:41 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(leftEmpty + " : " + rightEmpty + " | " + minWastedSpace );
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:49:52 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " leftEmpty + " : " + rightEmpty + " | " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:49:59 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " leftEmpty + " : " + rightEmpty + " | " + optimalBound + " - "minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
Compile error
Solution.java:57: error: ')' expected
System.out.println(bound + " - " leftEmpty + " : " + rightEmpty + " | " + optimalBound + " - "minWastedSpace);
^
Solution.java:57: error: not a statement
System.out.println(bound + " - " leftEmpty + " : " + rightEmpty + " | " + optimalBound + " - "minWastedSpace);
^
Solution.java:57: error: ';' expected
System.out.println(bound + " - " leftEmpty + " : " + rightEmpty + " | " + optimalBound + " - "minWastedSpace);
^
Solution.java:57: error: ';' expected
System.out.println(bound + " - " leftEmpty + " : " + rightEmpty + " | " + optimalBound + " - "minWastedSpace);
^
4 errors
Code: 21:50:09 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalBound + " - "minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:50:11 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalBound + " - " +minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
Compile error
Solution.java:57: error: cannot find symbol
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalBound + " - " +minWastedSpace);
^
symbol: variable optimalBound
location: class Solution
1 error
Code: 21:50:28 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
Compile error
Solution.java:57: error: variable optimalbound might not have been initialized
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
^
1 error
Code: 21:50:38 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
expand all
Example tests
1.
0.072 s
WRONG ANSWER,
got 12 expected 10
stdout:
2 - 4 : 0 | 3 - 12 1 - 2 : 0 | 2 - 4 0 - 0 : 3 | 1 - 2
1.
0.072 s
WRONG ANSWER,
got 20 expected 17
stdout:
3 - 6 : 0 | 4 - 20 2 - 5 : 0 | 3 - 6 1 - 2 : 2 | 2 - 5 0 - 0 : 3 | 1 - 4
1.
0.072 s
WRONG ANSWER,
got 25 expected 19
stdout:
4 - 9 : 0 | 5 - 25 3 - 5 : 0 | 4 - 9 2 - 2 : 1 | 3 - 5 1 - 2 : 7 | 2 - 3 0 - 0 : 9 | 2 - 3
1.
0.072 s
OK
stdout:
4 - 4 : 0 | 5 - 35 3 - 4 : 0 | 4 - 4 2 - 4 : 0 | 4 - 4 1 - 0 : 4 | 4 - 4 0 - 0 : 4 | 4 - 4
1.
0.072 s
WRONG ANSWER,
got 42 expected 30
stdout:
5 - 15 : 0 | 6 - 42 4 - 14 : 0 | 5 - 15 3 - 13 : 0 | 4 - 14 2 - 12 : 0 | 3 - 13 1 - 0 : 3 | 2 - 12 0 - 0 : 9 | 1 - 3
Code: 21:51:14 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound +);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:51:17 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound);
int[] rightBanner = Arrays.copyOfRange(H, bound, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.IllegalArgumentException: 0 > -1 at java.base/java.util.Arrays.copyOfRange(Arrays.java:4101) at Solution.solution(Solution.java:65) at Exec.run(exec.java:48) at Exec.main(exec.java:34)stdout:
2 - 4 : 0 | 3 - 12 1 - 2 : 0 | 2 - 4 0 - 0 : 3 | 1 - 2
1.
0.068 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.IllegalArgumentException: 0 > -1 at java.base/java.util.Arrays.copyOfRange(Arrays.java:4101) at Solution.solution(Solution.java:65) at Exec.run(exec.java:48) at Exec.main(exec.java:34)stdout:
3 - 6 : 0 | 4 - 20 2 - 5 : 0 | 3 - 6 1 - 2 : 2 | 2 - 5 0 - 0 : 3 | 1 - 4
1.
0.068 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.IllegalArgumentException: 0 > -1 at java.base/java.util.Arrays.copyOfRange(Arrays.java:4101) at Solution.solution(Solution.java:65) at Exec.run(exec.java:48) at Exec.main(exec.java:34)stdout:
4 - 9 : 0 | 5 - 25 3 - 5 : 0 | 4 - 9 2 - 2 : 1 | 3 - 5 1 - 2 : 7 | 2 - 3 0 - 0 : 9 | 2 - 3
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.IllegalArgumentException: 0 > -1 at java.base/java.util.Arrays.copyOfRange(Arrays.java:4101) at Solution.solution(Solution.java:65) at Exec.run(exec.java:48) at Exec.main(exec.java:34)stdout:
4 - 4 : 0 | 5 - 35 3 - 4 : 0 | 4 - 4 2 - 4 : 0 | 4 - 4 1 - 0 : 4 | 4 - 4 0 - 0 : 4 | 4 - 4
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Exception in thread "main" java.lang.IllegalArgumentException: 0 > -1 at java.base/java.util.Arrays.copyOfRange(Arrays.java:4101) at Solution.solution(Solution.java:65) at Exec.run(exec.java:48) at Exec.main(exec.java:34)stdout:
5 - 15 : 0 | 6 - 42 4 - 14 : 0 | 5 - 15 3 - 13 : 0 | 4 - 14 2 - 12 : 0 | 3 - 13 1 - 0 : 3 | 2 - 12 0 - 0 : 9 | 1 - 3
Code: 21:51:52 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:51:59 UTC,
java11,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
expand all
Example tests
1.
0.076 s
WRONG ANSWER,
got 12 expected 10
stdout:
2 - 4 : 0 | 3 - 12 1 - 2 : 0 | 2 - 4 0 - 0 : 3 | 1 - 2
1.
0.072 s
WRONG ANSWER,
got 20 expected 17
stdout:
3 - 6 : 0 | 4 - 20 2 - 5 : 0 | 3 - 6 1 - 2 : 2 | 2 - 5 0 - 0 : 3 | 1 - 4
1.
0.072 s
WRONG ANSWER,
got 25 expected 19
stdout:
4 - 9 : 0 | 5 - 25 3 - 5 : 0 | 4 - 9 2 - 2 : 1 | 3 - 5 1 - 2 : 7 | 2 - 3 0 - 0 : 9 | 2 - 3
1.
0.072 s
OK
stdout:
4 - 4 : 0 | 5 - 35 3 - 4 : 0 | 4 - 4 2 - 4 : 0 | 4 - 4 1 - 0 : 4 | 4 - 4 0 - 0 : 4 | 4 - 4
1.
0.072 s
WRONG ANSWER,
got 42 expected 30
stdout:
5 - 15 : 0 | 6 - 42 4 - 14 : 0 | 5 - 15 3 - 13 : 0 | 4 - 14 2 - 12 : 0 | 3 - 13 1 - 0 : 3 | 2 - 12 0 - 0 : 9 | 1 - 3
Code: 21:53:58 UTC,
java11,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
Sy
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:54:20 UTC,
java11,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
System.out.println(Arrays.toString(leftBanner) + " | " + Arrays.toString(rightBanner));
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
expand all
Example tests
1.
0.092 s
WRONG ANSWER,
got 12 expected 10
stdout:
2 - 4 : 0 | 3 - 12 1 - 2 : 0 | 2 - 4 0 - 0 : 3 | 1 - 2 [] | [3, 1, 4]
1.
0.092 s
WRONG ANSWER,
got 20 expected 17
stdout:
3 - 6 : 0 | 4 - 20 2 - 5 : 0 | 3 - 6 1 - 2 : 2 | 2 - 5 0 - 0 : 3 | 1 - 4 [] | [5, 3, 2, 4]
1.
0.092 s
WRONG ANSWER,
got 25 expected 19
stdout:
4 - 9 : 0 | 5 - 25 3 - 5 : 0 | 4 - 9 2 - 2 : 1 | 3 - 5 1 - 2 : 7 | 2 - 3 0 - 0 : 9 | 2 - 3 [] | [5, 3, 5, 2, 1]
1.
0.092 s
OK
stdout:
4 - 4 : 0 | 5 - 35 3 - 4 : 0 | 4 - 4 2 - 4 : 0 | 4 - 4 1 - 0 : 4 | 4 - 4 0 - 0 : 4 | 4 - 4 [] | [7, 7, 3, 7, 7]
1.
0.092 s
WRONG ANSWER,
got 42 expected 30
stdout:
5 - 15 : 0 | 6 - 42 4 - 14 : 0 | 5 - 15 3 - 13 : 0 | 4 - 14 2 - 12 : 0 | 3 - 13 1 - 0 : 3 | 2 - 12 0 - 0 : 9 | 1 - 3 [] | [1, 1, 7, 6, 6, 6]
Code: 21:55:10 UTC,
java11,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, bound + 1);
int[] rightBanner = Arrays.copyOfRange(H, bound + 1, H.length);
System.out.println(Arrays.toString(leftBanner) + " | " + Arrays.toString(rightBanner) + );
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:55:24 UTC,
java11,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
System.out.println(Arrays.toString(leftBanner) + " | " + Arrays.toString(rightBanner) + " : " + optimalbound);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
expand all
Example tests
1.
0.120 s
OK
stdout:
2 - 4 : 0 | 3 - 12 1 - 2 : 0 | 2 - 4 0 - 0 : 3 | 1 - 2 [3, 1] | [4] : 1
1.
0.116 s
OK
stdout:
3 - 6 : 0 | 4 - 20 2 - 5 : 0 | 3 - 6 1 - 2 : 2 | 2 - 5 0 - 0 : 3 | 1 - 4 [5] | [3, 2, 4] : 0
1.
0.116 s
OK
stdout:
4 - 9 : 0 | 5 - 25 3 - 5 : 0 | 4 - 9 2 - 2 : 1 | 3 - 5 1 - 2 : 7 | 2 - 3 0 - 0 : 9 | 2 - 3 [5, 3, 5] | [2, 1] : 2
1.
0.116 s
OK
stdout:
4 - 4 : 0 | 5 - 35 3 - 4 : 0 | 4 - 4 2 - 4 : 0 | 4 - 4 1 - 0 : 4 | 4 - 4 0 - 0 : 4 | 4 - 4 [7, 7, 3, 7, 7] | [] : 4
1.
0.116 s
OK
stdout:
5 - 15 : 0 | 6 - 42 4 - 14 : 0 | 5 - 15 3 - 13 : 0 | 4 - 14 2 - 12 : 0 | 3 - 13 1 - 0 : 3 | 2 - 12 0 - 0 : 9 | 1 - 3 [1, 1] | [7, 6, 6, 6] : 1
Code: 21:56:23 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
// int smallestBuilding = Arrays.stream(H).min().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
// double avgHeight = Arrays.stream(H).mapToDouble(a -> a).average().orElse(0.0);
// brute force approach
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
System.out.println(bound + " - " + leftEmpty + " : " + rightEmpty + " | " + optimalbound + " - " + minWastedSpace);
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:56:36 UTC,
java11,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:56:53 UTC,
java11,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:57:04 UTC,
java11,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
User test case 1:
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1]
Code: 21:57:33 UTC,
java11,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:57:57 UTC,
java11,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
User test case 1:
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1]
User test case 2:
[20, 1]
User test case 3:
[50]
User test case 4:
[1]
User test case 5:
[1, 10, 1]
Code: 21:59:04 UTC,
java11,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:59:24 UTC,
java11,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
System.out.println(Arrays.toString(leftBanner) + " " + Arrays.toString(rightBanner));
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
expand all
Example tests
1.
0.044 s
OK
stdout:
[3, 1] [4]
1.
0.044 s
OK
stdout:
[5] [3, 2, 4]
1.
0.044 s
OK
stdout:
[5, 3, 5] [2, 1]
1.
0.044 s
OK
stdout:
[7, 7, 3, 7, 7] []
1.
0.040 s
OK
stdout:
[1, 1] [7, 6, 6, 6]
expand all
User tests
1.
0.044 s
OK
function result: 16
function result: 16
stdout:
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2, 1]
1.
0.040 s
OK
function result: 21
function result: 21
stdout:
[20] [1]
1.
0.044 s
OK
function result: 50
function result: 50
stdout:
[50] []
1.
0.044 s
OK
function result: 1
function result: 1
stdout:
[1] []
1.
0.044 s
OK
function result: 21
function result: 21
stdout:
[1, 10] [1]
User test case 1:
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1]
User test case 2:
[20, 1]
User test case 3:
[50]
User test case 4:
[1]
User test case 5:
[1, 10, 1]
Code: 21:59:45 UTC,
java11,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Code: 21:59:52 UTC,
java11,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis
User test case 1:
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1]
User test case 2:
[20, 1]
User test case 3:
[50]
User test case 4:
[1]
User test case 5:
[1, 10, 1]
Code: 22:00:01 UTC,
java11,
final,
score:
50
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// 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[] H) {
int totalBuildingsArea = Arrays.stream(H).sum();
int tallestBuilding = Arrays.stream(H).max().getAsInt();
int totalArea = tallestBuilding * H.length;
int emptySpace = 0;
for (int b : H) {
emptySpace += tallestBuilding - b;
}
int bound;
int optimalbound = H.length;
int minWastedSpace = totalArea;
for (bound = H.length - 1; bound >= 0; bound--) {
int tallestLeft, leftCoverage, leftEmpty;
tallestLeft = leftCoverage = leftEmpty = 0;
for (int left = 0; left <= bound; left++) {
if (H[left] > tallestLeft)
tallestLeft = H[left];
leftCoverage += H[left];
}
for (int left = 0; left <= bound; left++) {
leftEmpty += tallestLeft - H[left];
}
int tallestRight, rightCoverage, rightEmpty;
tallestRight = rightCoverage = rightEmpty = 0;
for (int right = bound + 1; right < H.length; right++) {
if (H[right] > tallestRight)
tallestRight = H[right];
rightCoverage += H[right];
}
for (int right = bound + 1; right < H.length; right++) {
rightEmpty += tallestRight - H[right];
}
if ((leftEmpty + rightEmpty) < minWastedSpace) {
optimalbound = bound;
minWastedSpace = (leftEmpty + rightEmpty);
}
}
int[] leftBanner = Arrays.copyOfRange(H, 0, optimalbound + 1);
int[] rightBanner = Arrays.copyOfRange(H, optimalbound + 1, H.length);
int bannerSize = (Arrays.stream(leftBanner).max().orElse(0) * leftBanner.length)
+ (Arrays.stream(rightBanner).max().orElse(0) * rightBanner.length);
return bannerSize;
}
}
Analysis summary
The following issues have been detected: timeout errors.
Analysis
Detected time complexity:
O(N**2)
expand all
Correctness tests
1.
0.004 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
4.
0.004 s
OK
5.
0.008 s
OK
6.
0.008 s
OK
1.
0.004 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
4.
0.004 s
OK
5.
0.008 s
OK
1.
0.004 s
OK
2.
0.008 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.004 s
OK
4.
0.004 s
OK
5.
0.008 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.004 s
OK
4.
0.004 s
OK
5.
0.008 s
OK
6.
0.008 s
OK
1.
0.016 s
OK
2.
0.016 s
OK
3.
0.020 s
OK
4.
0.020 s
OK
expand all
Performance tests
distinct_large
Every value in the array is different. N=7,500.
Every value in the array is different. N=7,500.
✘
TIMEOUT ERROR
running time: 2.184 sec., time limit: 0.100 sec.
running time: 2.184 sec., time limit: 0.100 sec.
1.
2.184 s
TIMEOUT ERROR,
running time: 2.184 sec., time limit: 0.100 sec.
2.
2.168 s
TIMEOUT ERROR,
running time: 2.168 sec., time limit: 0.100 sec.
3.
2.168 s
TIMEOUT ERROR,
running time: 2.168 sec., time limit: 0.100 sec.
4.
2.168 s
TIMEOUT ERROR,
running time: 2.168 sec., time limit: 0.100 sec.
random_max
Random maximum tests. N=100,000.
Random maximum tests. N=100,000.
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
4.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
various_max
Various hard hand-created tests. N=100,000.
Various hard hand-created tests. N=100,000.
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
4.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
5.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
6.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
max_pyramid
Values in the tests are arranged into ascending or descending pyramids. N=100,000.
Values in the tests are arranged into ascending or descending pyramids. N=100,000.
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
4.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
5.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
1.
7.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 7.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
4.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
5.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
6.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
7.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.