Question

圣诞快乐，希望你有很棒的精神，我在Java-Arrays中有一个问题，如下所示。我很挣扎着努力去做它。

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，答案是4 coz MaxSpan 1到1之间是4 maxSpan（{1,4,2,1,4,1,4}）→6，答案是6 coz MaxSpan 4到4之间是6 maxSpan（{1,4,2,1,4,4,4}）→6，答案是6 coz Maxspan在4到4之间是6，它大于MaxSpan在1和1之间是4，因此6> 4回答是6.

我的代码不起作用，它包含给定元素的所有Spans，我无法找到给定元素的MaxSpan。

请帮帮我。

上述计划的结果如下所示

预期此次运行 maxSpan（{1,2,1,1,3}）→4 5 X
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 X
maxSpan（{3,9,3}）→3 3 OK
maxSpan（{3,9,9}）→2 3 X
maxSpan（{3,9}）→1 1 OK
maxSpan（{3,3}）→2 3 X
maxSpan（{}）→0 1 X
maxSpan（{1}）→1 1 OK

:: Code ::

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

由于已经给出了解决方案，因此这是一种使用一次通过的更有效的解决方案。

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

Answer 2

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

您的count完全错误。您可以改为从count和i计算j：j - i + 1
一旦获得任何范围，您就会覆盖maxcount，因此您将最终获得 last 范围，而不是最大范围。转到maxspan = Math.max(maxspan, count);。
您可以删除行int number = nums[i];，因为您从未使用过number。
删除+1 maxspan + 1中的return;如果您按照上述提示删除。
如果数组中有任何值，则初始maxspan应为1，如果数组为空，则为0。

这应该可以帮助你实现目标。请注意，您可以在数组的单次传递中执行此操作，但这可能会让您的距离太大。在考虑效率之前，集中精力让代码工作。

Answer 3

以下是此问题的解决方案：

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

Answer 4

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

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 5

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

Answer 6

这是解决方案 -

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

Answer 7

一个强力解决方案可能是这样的，从数组中取一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 8

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

Answer 9

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

Answer 10

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

Answer 11

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

    }
}

Answer 12

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

Answer 13

上述解决方案很棒，如果你的目标是避免使用Arrays.asList和indexOf以及LastIndexOf，下面的代码尽可能地使工作变得懒惰，同时仍然清晰简洁。

    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.

Answer 14

我就这样做了：

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

Answer 15

我不确定，我是否必须使用2 for-loops ...或任何循环？

如果没有，这个版本的功能没有任何循环。

首先检查一下，如果数组的长度是> 0.如果没有，您只需返回数组的长度，这将对应于正确的答案。

如果长度大于0，则检查数组中的第一个和最后一个位置是否具有相同的值。

如果是，则返回数组的长度maxSpan。

如果不是，则减去1，因为数值在数组中出现两次。

完成。

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

Answer 16

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

Answer 17

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

Answer 18

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

Answer 19

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

Answer 20

使用Map存储第一个匹配项的线性解法，并计算下次出现的距离：

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

Answer 21

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

Answer 22

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

Answer 23

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

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

23 个答案: