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

圣诞快乐，希望你们心情愉快，我有一个关于Java数组的问题，如下所示。我一直在为得到它而努力

考虑数组中某个值的最左边和最右边的外观。我们可以说“span”是两个元素之间的元素数。单个值的范围为1。编写一个**Java函数**，返回给定数组中的最大跨度。

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

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

请帮帮我

上述计划的结果如下所示

预计会有这次跑步
maxSpan（{1,2,1,1,3}）→ 4.5倍
maxSpan（{1,4,2,1,4,1,4}）→ 6.8 X
最大跨距（{1,4,2,1,4,4,4}）→ 69x
maxSpan（{3,3,3}）→ 3.5倍
maxSpan（{3,9,3}）→ 3正常
maxSpan（{3,9,9}）→ 23x
maxSpan（{3，9}）→ 1 1正常
maxSpan（{3，3}）→ 23x
maxSpan（{}）→ 0 1 X
最大跨距（{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        
}    

public int maxSpan（int[]nums）{
int count=1；//保留maxspan=1的初始计数
int maxspan=0；//初始化maxspan=0
对于（int i=0；i我发现您的尝试存在以下问题：


您的
计数
完全错误。您可以从
i
和
j
计算
计数
：
j-i+1

一旦得到任何跨度，您将覆盖
maxcount
，因此您将得到最后一个跨度，而不是最大跨度。通过执行
maxspan=Math.max（maxspan，count）；
来修复它

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

如果您遵循上面的提示，请删除
返回
maxspan+1；`中的
+1

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


这应该有助于您使其正常工作。请注意，您可以在数组的一次遍历中完成此操作，但这可能会使您的代码太长。在考虑效率之前，请集中精力使代码正常工作。
我使用了一个列表。这样做更简单。
唯一的问题是如果阵列太大，可能需要一段时间

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);
    }
}

import java.util.ArrayList；
导入java.util.List；
公共类堆栈溢出{
公共静态void main（字符串[]args）{
List listNumbers=new ArrayList（）；
增加（3）；
增加（3）；
增加（3）；
增加（2）；
增加（1）；
增加（4）；
增加（3）；
增加（5）；
增加（1）；
增加（1）；
增加（1）；
增加（1）；
增加（1）；
增加（3）；
int结果=0；
整数键=空；
for（整数i：列表编号）{
int resultDistance=返回距离（列表编号，i）；
如果（结果状态>结果）{
结果=结果状态；
key=i；
}
}
System.out.println（“键的最大跨距”+key+”为：“+result”）；
}
私有静态int returnDistance（列表列表编号，整数项）{
整数startPosition=null；
整数endPosition=null；
boolean-boolstartposition=false；
布尔结果=假；
整数计数=1；
int结果=0；
for（整数i：列表编号）{
if（i==术语和位置）{
起始位置=计数；
bolStartPosition=true；
持续
}
if（i==术语和位置）{
结束位置=计数；
}
计数++；
}
if（endPosition！=null）{
//因为它包含了双方
结果=结束位置-开始位置+2；
结果=真；
}
返回（结果？结果：-1）；
}
}
既然已经给出了一个解决方案，这里有一个更有效的解决方案，它使用一个过程

public static void main(String... args) {
    int maxspan = maxspan(3, 3, 3, 2, 1, 4, 3, 5, 3, 1, 1, 1, 1, 1);
    System.out.println(maxspan);
}

private static int maxspan(int... ints) {
    Map<Integer, Integer> first = new LinkedHashMap<Integer, Integer>(); // use TIntIntHashMap for efficiency.
    int maxspan = 0;  // max span so far.
    for (int i = 0; i < ints.length; i++) {
        int num = ints[i];
        if (first.containsKey(num)) {  // have we seen this number before?
            int span = i - first.get(num) + 1;  // num has been  found so what is the span
            if (span > maxspan) maxspan = span;  // if the span is greater, update the maximum.
        } else {
            first.put(num, i); // first occurrence of number num at location i.
        }
    }
    return maxspan;
}

publicstaticvoidmain（字符串…参数）{
int maxspan=maxspan（3,3,3,2,1,4,3,5,3,1,1,1,1,1）；
System.out.println（maxspan）；
}
专用静态整数最大跨距（整数…整数）{
Map first=new LinkedHashMap（）；//使用TIntIntHashMap提高效率。
int maxspan=0；//到目前为止的最大跨度。
for（int i=0；imaxspan）maxspan=span；//如果跨度更大，则更新最大值。
}否则{
first.put（num，i）；//在位置i第一次出现num。
}
}
返回最大跨度；
}
public int maxSpan（int[]nums）{
//将数字转换为字符串
字符串编号=”；
如果（nums.length==0）
返回0；
对于（int ndx=0；ndxpublic int maxSpan(int[] nums) {

//convert the numnber to a string
  String numbers = "";
 if (nums.length == 0) 
   return 0;
 for(int ndx = 0; ndx < nums.length;ndx++){
    numbers += nums[ndx];
 }
 //check beginning and end of string
   int first = numbers.indexOf(numbers.charAt(0));
   int last = numbers.lastIndexOf(numbers.charAt(0));
   int max = last - first + 1;

   int efirst = numbers.indexOf(numbers.charAt(numbers.length()-1));
   int elast = numbers.lastIndexOf(numbers.charAt(numbers.length()-1));
   int emax = elast - efirst + 1;
//return the max span.
   return (max > emax)?max:emax;
}

public int maxSpan(int[] nums) {
    int current = 0;
    int currentcompare = 0;
    int counter = 0;
    int internalcounter = 0;

    if(nums.length == 0)
        return 0;

    for(int i = 0; i < nums.length; i++) {
        internalcounter = 0;
        current = nums[i];

        for(int x = i; x < nums.length; x++) {
            currentcompare = nums[x];

            if(current == currentcompare) {
                internalcounter = x - i;
            }

            if(internalcounter > counter) {
                counter = internalcounter;
            }
        }
    }
    return counter + 1;
}

public int maxSpan(int[] nums) {
if(nums.length<1){
return 0;
}
int compare=1;
for (int i=0; i<nums.length; i++){
for (int l=1; l<nums.length; l++){
if((nums[l]==nums[i])&&(Math.abs(l)-Math.abs(i))>=compare){
compare = Math.abs(l)-Math.abs(i)+1;
}
}
}  
return compare;
}

public int maxSpan(int[] nums) {
        int maxSpan=0;
        int tempSpan=0;

        if(nums.length==0){
            return 0;
        }

        for(int i=0;i<nums.length;i++){   
            for(int j=nums.length-1;j>i;j--){ 
                if(nums[i]==nums[j]){
                    tempSpan=j-i;
                    break;
                } 
            } 
            if(tempSpan>maxSpan){
                maxSpan=tempSpan;
            } 
        } 
        return maxSpan+1;
    }

public static int MaxSpan(int[] input1, int key)
{
    int Span = 0;
    int length = input1.length;
    int i,j,k = 0;
    int start = 0, end = 0 ;
    k = key;
    for (int l = 0; l < length; l++) {
        if(input1[l] == k) { start = l;
        System.out.println("\nStart  = " + start);
        break;
        }
    }

    if(start == 0) { Span = 0; System.out.println("Key not found"); return Span;}

    for (j = length-1; j> start; j--) {
        if(input1[j] == k) { end = j;
        System.out.println("\nEnd = " + end);
        break;
        }
    }
    Span = end - start;  
    System.out.println("\nStart  = " + start + "End = " + end + "Span = " + Span);
    return Span;
}  

public int maxSpan(int[] nums) {

  int length = nums.length;  

  if(length <= 0)
     return 0;

  int left = nums[0];
  int rigth = nums[length - 1];
  int value = 1;

  //If these values are the same, then the max span is length
  if(left == rigth)
    return length;

  // the last match is the largest span for any value
  for(int x = 1; x < length - 1; x++)
  {     
     if(nums[x] == left || nums[x] == rigth)
       value = x + 1;    
  }

  return value;
}

public int maxSpan(int[] nums) {

int count, largest=0;

for (int x=0; x< nums.length; x++)
{ 
    for (int y=0; y< nums.length; y++)
    {
    if (nums[x]==nums[y])
    {
    count= y-x+1;
    if (count > largest)
    {
    largest= count;
    }
    }    
    }
}

return largest;
}

import java.io.*;
public class maxspan {
    public static void main(String args[])throws java.io.IOException{
        int A[],span=0,pos=0;
        DataInputStream in=new DataInputStream(System.in);
        System.out.println("enter the number of elements");

        A=new int[Integer.parseInt(in.readLine())];
        int i,j;
        for(i=0;i<A.length;i++)
        {
            A[i]=Integer.parseInt(in.readLine());
        }
        for(i=0;i<A.length;i++)
        {
            for(j=A.length-1;j>=0;j--)
                if(A[i]==A[j]&&(j-i)>span){span=j-i;pos=i;}
        }
        System.out.println("maximum span => "+(span+1)+" that is of "+A[pos]);

    }
}

public static int maxSpan(int[] nums) {
    int left = 0;
    int right = 0;

    for (int i = 0; i < nums.length; i++) {
        if (nums[0] == nums[nums.length - 1 - i]) {
            left = nums.length - i;
            break;
        } else if (nums[nums.length - 1] == nums[i]) {
            right = nums.length - i;
            break;
        }
    }
    return Math.max(left, right);
}

    public int maxSpan(int[] nums) {
           if(nums.length < 2){ //weed out length 0 and 1 cases
           return nums.length;
           }
           int maxSpan = 1; //start out as 1
           for(int a = 0; a < nums.length; a++){
               for(int b = nums.length - 1; b > a; b--){
                   if(nums[a] == nums[b]){
                   maxSpan = Math.max(maxSpan, (b + 1 - a));
                   //A little tricky getting those indices together.
                   break; //there's no reason to continue, 
                   //at least for this single loop execution inside another loop  
                   }
               }
           }
           return maxSpan; //the maxSpan is here!
        }

The Math.max method returns the larger of 2 values, one of them if they are equal.

public int maxSpan(int[] nums) {
  for (int span=nums.length; span>0; span--) {
    for (int i=0; i<nums.length-span+1; i++) {
      if (nums[i] == nums[i+span-1]) return span;
    }
  }
  return 0;
}

public int maxSpan(int[] nums) {
  if(nums.length > 0){
    if(nums[0] == nums[nums.length - 1]){
      return nums.length;
    }
    else{
      return nums.length - 1;  
    }   
  }
  return nums.length;
}

   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;
}

public int maxSpan(int[] nums) {
  Stack stack = new Stack();
  int count = 1;
  int value = 0;
  int temp = 0;
  if(nums.length < 1) {
    return value;
  }
  for(int i = 0; i < nums.length; i++) {
    for(int j = nums.length - 1; j >= i; j--) {
      if(nums[i] == nums[j]) {
        count = (j - i) + 1;
        stack.push(count);
        count = 1;
        break;
      }
    }
  }
  if(stack.peek() != null) {
  while(stack.size() != 0) {
    temp = (Integer) stack.pop();
    if(value <= temp) {
      value = temp;
    } else {
      value = value;
    }
  }
  }
  return value;
}

public int maxSpan(int[] nums) {
  int totalspan=0;
  int span=0;
  for(int i=0;i<nums.length;i++)
  {
    for (int j=nums.length-1;j>i-1;j--)
    {
      if(nums[i]==nums[j])
      {
      span=j-i+1;
      if (span>totalspan)
      totalspan=span;
      break;
      }
    }
  }
  return totalspan;
}

public int maxSpan(int[] nums) {
  int max_span=0, j;
  for (int i=0; i<nums.length; i++){
    j=nums.length-1;
    while(nums[i]!=nums[j]) j--;
    if (j-i+1>max_span) max_span=j-i+1;
  }
  return max_span;
}

public int maxSpan(int[] nums) {
  int span = 0;
  Map<Integer, Integer> first = new HashMap<Integer, Integer>();
  for (int i = 0; i < nums.length; i++) {
    if (!first.containsKey(nums[i])) 
      first.put(nums[i], i);
    span = Math.max(span, (i - first.get(nums[i])) + 1);
  }
  return span;
}

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;
}

public int maxSpan(int[] nums) {
  int span = 0;
  for (int i = 0; i < nums.length; i++) {
    for(int j = i; j < nums.length; j++) {
      if(nums[i] == nums[j]) {
        if(span < (j - i + 1)) {
          span = j -i + 1;
        }
      }
    }
  }
  return span;
}

public int maxSpan(int[] nums) {
 int span = 0;
 
 //Given the values at position i 0..length-1
 //find the rightmost position of that value nums[i]
 for (int i = 0; i < nums.length; i++) {
   // find the rightmost of nums[i]
   int j =nums.length -1;
   while(nums[i]!=nums[j])
   j--;
   // j is at the rightmost posititon of nums[i]
   span  = Math.max(span,j-i+1);
     
   }
 
 return span;
}