Question

我的课程是在Java入门书的第18章，这是关于递归的章节。所以这就是它所说的：

＆＃34;对于此赋值，您将编写两个递归函数，这两个函数将解析由数字和数字组成的任何长度字符串。这两个函数应该在同一个类中，并具有以下签名。＆＃34;

现在第一个是int sumIt（String s）来对给定字符串中的int进行求和。我完成了这个部分，你只需要查看每个字符，看看它是否是一个数字，然后将其添加到总数中，如果是这样的话。然后在返回中，调用删除了char的函数。

第二个函数是int findMax（String s，int max）。所以基本上我认为它将起作用的方式是你从max 0开始然后在返回中再次调用该函数，并且每次检查下一个int是否大于max，并且如果是则替换。我最初写的这个与第一个函数非常相似（检查我的代码），但后来我意识到，在这一个中，你不能逐字逐句。如果字符串是＆＃34; xg12zz128-p / 9＆＃34;最大值应该是128.似乎不是获取字符串中下一个整数的简单方法。我不知道该怎么办。

这是我的代码：

public class Finder {


    public int sumIt(String s) {

        int total = 0;

        if(s.length() > 0) {  // checks that the string still has characters
            if(s.substring(0, 1).matches("[0-9]")) {   // checks if the first character is a number
                total += Integer.parseInt(s.substring(0, 1)); // if num, parses into integer and adds it total
                return total + sumIt(s.substring(1)); // return total and use recursursion to continue searching the string for ints
            }
            else {
                return total + sumIt(s.substring(1));  // needed this else clause in case the char was not a number
            }
        }
        else {
            return total; // return total when there are no more characters
        }
    }

    public int findMax(String s, int max) {

        if (s.length() > 0) { // checks for characters

            if(s.substring(0, 1).matches("[0-9]")) { // checks for number

                int a = Integer.parseInt(s.substring(0, 1));     // parse num to int    

                if(a > max) {
                    return findMax(s.substring(1), a);  // if the new int is bigger, we call the function again with that set as max
                }
                else return findMax(s.substring(1), max); // else we just use the old max
            }
            else return findMax(s.substring(1), max); // in case its not a num
        } 
        else return max; // return max when all characters are gone.
    }

}

然后是正在使用的JUnit测试文件。可能不需要查看此代码，但至少可以看到答案的示例。

package week4.Whitelaw;

import static org.junit.Assert.*;

import org.junit.Test;

public class TestRecursion
{

    @Test
    public void testSumIt()
    {
        Finder finder = new Finder();

        assertEquals(6, finder.sumIt("1d2d3d") );
        assertEquals(10, finder.sumIt("55") );
        assertEquals(0, finder.sumIt("xx") );
        assertEquals(1, finder.sumIt("00001") );
        assertEquals(3, finder.sumIt("x0x0w1y2") );
        assertEquals(21, finder.sumIt("123456") );
        assertEquals(21, finder.sumIt("x123456x") );
        assertEquals(7, finder.sumIt("1ggggg60") );
    }

    @Test
    public void testMax()
    {
        Finder finder = new Finder();

        // assume max is the smallest possible number
        int max = 0;

        assertEquals(12, finder.findMax("12x8",max) );
        assertEquals(88, finder.findMax("012x88",max) );
        assertEquals(100, finder.findMax("012x88ttttt9xe33ppp100",max) );
        assertEquals(128, finder.findMax("128",max) );
        assertEquals(0, finder.findMax("abcdef",max) );
        assertEquals(123456, finder.findMax("123456",max) );
        assertEquals(2, finder.findMax("x2x1x",max) );
    }

}

任何帮助将不胜感激!!

Answer 1

使用伪代码，因为你的问题集中在逻辑而不是语法上，这是一个可能的解决方案，

findMax(string s, int currentMax, int currentInt)
    if s is empty
        return currentMax
    if s.firstChar() is not an int
        currentMax = max(currentMax, currentInt)
        return findMax(s.substring(1), currentMax, 0)
    int t = parseInt(s.firstChar())
    currentInt = currentInt * 10 + t
    return findMax(s.substring(1), currentMax, currentInt)

Answer 2

你也不能逐字逐字。如果你这样做了，当实际答案应该是22时，你会得到字符串ab11cd11ed的结果为4。

Answer 3

我看到你已经在使用正则表达式，所以我认为有可能你会被允许做更多的事情。如果是这样，您可以执行以下操作：

    Pattern integerPattern = Pattern.compile("^\\d+");
    Matcher m = integerPattern.matcher(input);
    if (m.find()) {
        String integerAsString = m.group();
        // ...
    } else // ...

现在，您可以解析整数，并使用与integerAsString的长度相同的字符数移除来执行递归调用。我相信你自己完成它。当然，如果您愿意，integerPattern可以是班级中的静态常量。

使用递归，从一串数字和字母中获取max int？

3 个答案: