docs: public static Cluster
              balanceContiguousPartitionsPerZone(final Cluster nextCandidateCluster,
                                                 final int maxContiguousPartitionsPerZone) {
          System.out.println("Balance number of contiguous partitions within a zone.");
          System.out.println("numPartitionsPerZone");
          for(int zoneId: nextCandidateCluster.getZoneIds()) {
              System.out.println(zoneId + " : "
                                 + nextCandidateCluster.getNumberOfPartitionsInZone(zoneId));
          }
          System.out.println("numNodesPerZone");
          for(int zoneId: nextCandidateCluster.getZoneIds()) {
              System.out.println(zoneId + " : " + nextCandidateCluster.getNumberOfNodesInZone(zoneId));
          }
  
          // Break up contiguous partitions within each zone
          HashMap<Integer, List<Integer>> partitionsToRemoveFromZone = Maps.newHashMap();
          System.out.println("Contiguous partitions");
          for(Integer zoneId: nextCandidateCluster.getZoneIds()) {
              System.out.println("\tZone: " + zoneId);
              Map<Integer, Integer> partitionToRunLength = PartitionBalanceUtils.getMapOfContiguousPartitions(nextCandidateCluster,
                                                                                                              zoneId);
  
              List<Integer> partitionsToRemoveFromThisZone = new ArrayList<Integer>();
              for(Map.Entry<Integer, Integer> entry: partitionToRunLength.entrySet()) {
                  if(entry.getValue() > maxContiguousPartitionsPerZone) {
                      List<Integer> contiguousPartitions = new ArrayList<Integer>(entry.getValue());
                      for(int partitionId = entry.getKey(); partitionId < entry.getKey()
                                                                          + entry.getValue(); partitionId++) {
                          contiguousPartitions.add(partitionId
                                                   % nextCandidateCluster.getNumberOfPartitions());
                      }
                      System.out.println("Contiguous partitions: " + contiguousPartitions);
                      partitionsToRemoveFromThisZone.addAll(Utils.removeItemsToSplitListEvenly(contiguousPartitions,
                                                                                               maxContiguousPartitionsPerZone));
                  }
              }
  
              partitionsToRemoveFromZone.put(zoneId, partitionsToRemoveFromThisZone);
              System.out.println("\t\tPartitions to remove: " + partitionsToRemoveFromThisZone);
          }
  
          Cluster returnCluster = Cluster.cloneCluster(nextCandidateCluster);
  
          Random r = new Random();
          for(int zoneId: returnCluster.getZoneIds()) {
              for(int partitionId: partitionsToRemoveFromZone.get(zoneId)) {
                  // Pick a random other zone Id
                  List<Integer> otherZoneIds = new ArrayList<Integer>();
                  for(int otherZoneId: returnCluster.getZoneIds()) {
                      if(otherZoneId != zoneId) {
                          otherZoneIds.add(otherZoneId);
                      }
                  }
                  int whichOtherZoneId = otherZoneIds.get(r.nextInt(otherZoneIds.size()));
  
                  // Pick a random node from other zone ID
                  int whichNodeOffset = r.nextInt(returnCluster.getNumberOfNodesInZone(whichOtherZoneId));
                  int whichNodeId = new ArrayList<Integer>(returnCluster.getNodeIdsInZone(whichOtherZoneId)).get(whichNodeOffset);
  
                  // Steal partition from one zone to another!
                  returnCluster = UpdateClusterUtils.createUpdatedCluster(returnCluster,
                                                                          whichNodeId,
                                                                          Lists.newArrayList(partitionId));
              }
          }
  
          return returnCluster;
  
      }