java查找数组中相同数字之间的最大跨度

Question

圣诞快乐，希望你们心情愉快，我有一个关于Java数组的问题，如下所示。我受够了这件事，努力想得到它

Consider the leftmost and righmost appearances of some value in an array. We'll say that the "span" is the number of elements between the two inclusive. A single value has a span of 1. Write a **Java Function** that returns the largest span found in the given array.

**示例：
maxSpan（{1,2,1,1,3}）→ 答案是4，因为1到1之间的最大跨度是4
maxSpan（{1,4,2,1,4,1,4}）→ 6，答案是6，因为4到4之间的最大跨度是6
maxSpan（{1,4,2,1,4,4,4}）→ 6，答案是6，因为4到4之间的最大跨度是6，大于1到1之间的最大跨度是4，因此6>；答案是

我有一个不工作的代码，它包含了给定元素的所有跨度，我找不到给定元素的最大跨度

请帮帮我

上述课程的结果如下所示

预计会有这次跑步
maxSpan（{1,2,1,1,3}）→ 4.5倍
maxSpan（{1,4,2,1,4,1,4}）→ 6.8 X
maxSpan（{1,4,2,1,4,4,4}）→ 6.9 X
maxSpan（{3,3,3}）→ 3.5倍
maxSpan（{3,9,3}）→ 3 3好的
maxSpan（{3,9,9}）→ 2.3 X
maxSpan（{3,9}）→ 1 1好的
maxSpan（{3，3}）→ 2.3 X
maxSpan（{}）→ 01 X
maxSpan（{1}）→ 1 1正常

：：代码：

public int maxSpan(int[] nums) {    
    int count=1;//keep an intial count of maxspan=1    
    int maxspan=0;//initialize maxspan=0    
    for(int i=0;i<nums.length;i++){    
        for(int j=i+1;j<nums.length;j++){    
              if(nums[i] == nums[j]){
                 //check to see if "i" index contents == "j" index contents    
                 count++;    //increment count
                 maxspan=count;  //make maxspan as your final count  
                 int number = nums[i]; //number=actual number for maxspan               
              }                            
        }       
    }    
  return maxspan+1; //return maxspan        
}    

Answer 1

一个蛮力解决方案可能是这样的，从数组中取一个item，从最左边找到第一个item，计算跨度，然后与之前的结果进行比较

public int maxSpan(int[] nums) {
  int result = 0;
  for(int i = 0; i < nums.length; i++) {
    int item = nums[i];
    int span = 0;
    for(int j = 0; j<= i; j++) {//find first occurance of item from the left
      if(nums[j]==item) {
        span = i -j+1;
        break;
      }
    }
    if(span>result) {
      result = span;
    }
  }
  return result;
}

Answer 2

我发现您的尝试存在以下问题：

• 你的count完全错了。你可以从i和j：j - i + 1

• 一旦你得到任何跨度，你就会覆盖maxcount，所以你最终会得到最后一个跨度，而不是最大跨度。通过maxspan = Math.max(maxspan, count);来修复它

• 您可以删除int number = nums[i];行，因为您从不使用number

• 删除returnmaxspan+1；`如果你遵循我上面的建议

• 如果数组中有任何值，则初始maxspan应为1，如果数组为空，则应为0

这应该能帮你工作。请注意，您可以在阵列的一次传递中执行此操作，但这可能会将阵列拉伸得太远。在考虑效率之前，集中精力让代码正常工作

Answer 3

我写了一份清单。更简单的方法。 唯一的问题是如果阵列太大，可能需要一段时间

import java.util.ArrayList;
import java.util.List;


public class StackOverflow {

    public static void main(String[] args) {
        List<Integer> listNumbers = new ArrayList<Integer>();
        listNumbers.add(3);
        listNumbers.add(3);
        listNumbers.add(3);
        listNumbers.add(2);
        listNumbers.add(1);
        listNumbers.add(4);
        listNumbers.add(3);
        listNumbers.add(5);
        listNumbers.add(1);
        listNumbers.add(1);
        listNumbers.add(1);
        listNumbers.add(1);
        listNumbers.add(1);
        listNumbers.add(3);

        int result = 0;
        Integer key = null;
        for(Integer i : listNumbers){
            int resultDistance = returnDistance(listNumbers, i);
            if (resultDistance > result){
                result = resultDistance;
                key = i;
            }
        }

        System.out.println("MaxSpan of key " + key + " is: " + result);
    }

    private static int returnDistance(List<Integer> listNumbers, Integer term){
        Integer startPosition = null;
        Integer endPosition = null;
        boolean bolStartPosition = false;
        boolean bolResult = false;
        int count = 1;
        int result = 0;
        for (Integer i : listNumbers){
            if (i == term && !bolStartPosition){
                startPosition = count;
                bolStartPosition = true;
                continue;
            }
            if (i == term && bolStartPosition){
                endPosition = count;
            }
            count++;
        }
        if (endPosition != null){
            // because it's inclusive from both sides
            result = endPosition - startPosition + 2;
            bolResult = true;
        }
        return (bolResult?result:-1);
    }
}

Answer 4

   public int maxSpan(int[] nums) {

    int b = 0;
    if (nums.length > 0) {
        for (int i = 0; i < nums.length; i++) {
            int a = nums[0];
            if (nums[i] != a) {

                b = nums.length - 1;

            } else {

                b = nums.length;
            }
        }
    } else {
        b = 0;

    }

    return b;
}