0

此方法应返回以目标开头的第一个字符串的索引。

如果没有字符串以目标开头，则返回 -1。

我的实现有效，但并未涵盖所有变体。

代码：

public int getIndex(ArrayList<String> text, String target)
    {
        int i = 0;
        int index = -1;
        boolean found = false;

        while (!found && i < text.size()) //supply condition
        {           
            for (String s : text) {
                if (s.contains(target)) {                    
                    found = true;
                } else {
                    i++;
                }

                if (found) index = i;
            }  
        }

        return index;
    }

测试部分：

public static void main(String[] args)
   {
       ArrayList<String> cities = new ArrayList<String>();
       cities.add("Chicago");
       cities.add("Houston");
       cities.add("San Jose");
       cities.add("Seattle");  
       cities.add("Denver");     

       Finder finder = new Finder();

       System.out.println(finder.getIndex(cities, "C"));
       System.out.println("Expected: 0");

       System.out.println(finder.getIndex(cities, "S"));
       System.out.println("Expected: 2");

       System.out.println(finder.getIndex(cities, "D"));
       System.out.println("Expected: 4");

       System.out.println(finder.getIndex(cities, "X"));
       System.out.println("Expected: -1");
   }

此代码具有覆盖50/50 输入：

  4
- Expected: 0
  3
- Expected: 2
  4
+ Expected: 4
  -1
+ Expected: -1

如何解决这个问题？

4

4 回答 4

2

您声称：

我的实现有效

根据测试，它看起来不像我。您的代码比它需要的复杂得多，这使得很难找到错误。问题是你无缘无故地有两个循环：

while (!found && i < text.size()) //supply condition
{           
    for (String s : text) {
    }
}

为什么你有这两个循环？您i在内循环中多次递增...

如果简化它，您可能会发现更容易通过所有测试：

public int getIndex(List<String> text, String target) {
    for (int i = 0; i < text.size(); i++) {
        if (text.get(i).startsWith(target)) {
            return i;
        }
    }
    return -1;
}

这是教条坚持每个方法只有一个return语句会导致代码更加混乱的情况之一。

请注意，我已将条件从contains（在您的代码中）更改startsWith为与描述匹配。您应该为这种差异添加一个测试 - 尝试找到一个存在于其中一个城市中的字符串，但该城市不是以该值开头的。

我还将参数类型更改为，List<String>因为您实际上并不需要它是ArrayList<String>. （通过一些工作你可以让它接受Iterable<String>，但这会更复杂。）

我还建议您开始使用 JUnit 或类似的东西进行测试，而不仅仅是使用System.out.println.

编辑：只是为了一点乐趣，一个版本采用Iterable<String>并使用它来更LinkedList<String>有效地处理：

public int getIndex(Iterable<String> elements, String target) {
    int index = 0;
    for (String element : elements) {
        if (element.startsWith(target)) {
            return index;
        }
        index++;
    }
    return -1;
}

（毕竟没那么难……）

于 2013-07-05T15:14:36.473 回答
1 
public int getIndex(ArrayList<String> text, String target)
    {

        for(int i=0;i < text.size();i++) 
        {           
           if(text.get(i).indexOf(target) == 0)
                return i;
        }

        return -1;
    }
于 2013-07-05T15:17:06.033 回答
1

进行以下更改：

  • 摆脱不必要的found变量
  • 替换contains为startsWith
  • 去掉for-loop，否则你会通过数据几次
  • while将-loop更改为for-loop

我明白了，这似乎有效：

public int getIndex(ArrayList<String> text, String target)
{
    int index = -1;

    for (int i = 0; index == -1 && i < text.size(); i++)
    {
       if (text.get(i).startsWith(target))
       {
           index = i;
       }
    }

    return index;
}

当然，您还可以进一步改进它。

于 2013-07-05T15:28:17.277 回答
0

用这个改变 getIndex 方法：

public int getIndex(ArrayList<String> text, String target)
{
    int i = 0;         

    for (String s : text) {
        // Use startsWith if you want to check if the string starts with target...
        // Use contains if you want to check if contains target... 
        if (s.startsWith(target)) {
            return i;
         }

        i++;
    }  

    return -1;
}
于 2013-07-05T15:27:13.027 回答