Count Letter递归方法

因此程序必须计算字符串中的字母数。除了递归循环外，我不允许使用循环。

方法必须看起来像这样：

static int numberOf(String text, char characterToCount)

输入：

abcbabcba(字符串(和b(字符(

输出：

4

这就是我的代码到目前为止的样子(我得到了堆栈溢出(：

static int numberOf(String text, char characterToCount) {
int i = 0;
int erg = 0;
if (text.length() != 0) {
if (i != text.length()) {
if (text.charAt(i) == characterToCount) {
i++;
erg++;
numberOf(text, characterToCount);
} else {
i++;
numberOf(text, characterToCount);
}
} else {
return erg;
}
}
return 0;
}

编辑

我只能使用String.charAt和String.length

问题是在调用该方法时没有减少文本，因此长度永远不会减少到0。以下是你应该做的事情。请注意，不需要向该方法传递索引。每次只需将文本减少1，并检查第一个字符是否与目标字符相等。

public static void main(String[] args) {
System.out.println(numberOf("ksjssjkksjssss", 's'));
}


static int numberOf(String text, char characterToCount) {
if (text.isEmpty()) {
return 0;
}

if (text.charAt(0) == characterToCount) {
// call method and add 1 since you found a character
return numberOf(text.substring(1), characterToCount) + 1;
}
// just call the method.
return numberOf(text.substring(1), characterToCount);

}

上面打印

好的，这是我的修改版本，以满足您只使用String.length和String.charAt的要求。char实际上是16位，所以我使用高位字节来存储当前索引。我为每个递归调用增加索引，以保持搜索的当前位置。当我把256加到字符上时，我实际上是把1加到高位字节上。

static int numberOf(String text, char ch) {
// stop when index exceeds text length
if (ch >> 8 >= text.length()) {
return 0;
}
if (text.charAt((ch >> 8)) == (ch & 0xff)) {
return numberOf(text, (char)(ch + 256)) + 1;
}
return numberOf(text, (char)(ch + 256));
}

在某些宽度大于8位的字符集上，这将无法正常工作。

WJS的答案看起来不错，但如果您想要更简单的解决方案，这可能也会有所帮助。

解决方案中的问题是，一个调用堆栈中i和erg的更新不会被下一个递归调用堆栈看到/使用，因为它们是局部变量，每个堆栈都有自己的i和erg副本。在numberOf方法的每次调用中，它们总是初始化为0。

如果不允许使用子字符串，那么一种方法是使用一个额外的变量来保存您正在比较的文本中的位置索引。

但在这样做的时候，您可能需要修改方法的签名(如果您不想使用类级静态变量(。由于您已经提到您的方法必须只有两个参数(text，charToCount(，因此轻松实现这一点的一种方法是使用辅助方法(包含额外的index参数(，并且您的方法可以调用它。

static int numberOf(String text, char characterToCount) {
return helper(text, characterToCount, 0);
}
static int helper(String text, char charToCount, int index) {
if (text.isEmpty() || index == text.length()) return 0;
int countCharOnRight = helper(text, charToCount, index+1);
return (text.charAt(index) == charToCount) ? 1 + countCharOnRight : countCharOnRight;
}

什么

static int numberOf(String text, char characterToCount) {
return numberOfRecursive(text, characterToCount, 0);
}
// Recursive helper function
static int numberOfRecursive(String text, char characterToCount, int index) {
if (index == text.length()) // Abort recursion
return 0;
if (text.charAt(index) == characterToCount) // check char at index, then check next recursively
return numberOfRecursive(text, characterToCount, index + 1) + 1;
else
return numberOfRecursive(text, characterToCount, index + 1);
}

为什么

大多数递归问题都需要一个帮助函数，它实际执行递归部分。它将从具有初始值的原始函数调用，这里是我们的文本、字符和起始位置0。

然后，递归函数需要一个中止条件，这是我通过绑定检查提供的。如果递归到达字符串的末尾，则终止。

最后，递归函数在递归调用的基础上进行一些计算。在这里，如果索引位置的字符是要计数的字符，我们将结果加1。如果没有，我们继续计数，不加1。

我希望我能帮上忙。

递归的思想是在某些条件之后多次调用相同的函数/方法。一个好的方法是调用相同的函数，但每次都要减少要检查的字符串。

类别

public class StringUtils {

public int numberOf(String text, char characterToCount) {
int count = 0;
if (text.length() != 0) {
if(text.charAt(0) == characterToCount) { //Only increment when is the same character
count++; 
}
count = count + numberOf(text.substring(1, text.length()), characterToCount); //Do a substring but remove the first character
}
return count;
}
}

测试

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class StringUtilsTest {

@Test
public void should_count_all_the_ocurrences() {

//Given
StringUtils utils = new StringUtils();
String sentence = "</www></palabraRandom></www></palabraRandom></palabraRandom></www>";

//When
int output = utils.numberOf(sentence, '>');

//Then
assertEquals(6, output);
}

}

所以我想我得到了我的解决方案。它可能不太好，但它有效。谢谢你的帮助：(

public class CountLetters {
public static void main(String[] args) {
print("Bitte geben Sie den Text ein: ");
String text = readString();
text = toLowerCase(text, 0);
print("Bitte geben Sie ein Zeichen ein: ");
String zeich = readString();
zeich = toLowerCase(zeich, 0);
if (zeich.length() > 1) {
throw new PR1Exception("Bitte nur einen Buchstaben eingeben. ");
}
char zeichen = zeich.charAt(0);
if (zeichen > 0 && zeichen < 65 && zeichen > 90 && zeichen < 97 && zeichen > 123) {
throw new PR1Exception("Bitte nur Buchstaben eingeben.");
}
int anzahl = numberOf(text, zeichen);
println("-> " + anzahl);
}
static String toLowerCase(String text, int i) {
String lowerText = "";
if (i == text.length()) {
return lowerText;
} else if (text.charAt(i) < 'a') {
return lowerText += (char) (text.charAt(i) - 'A' + 'a') + toLowerCase(text, i + 1);
} else {
return lowerText += text.charAt(i) + toLowerCase(text, i + 1);
}
}
static int numberOf(String text, char characterToCount) {
return hilfe(text, characterToCount, 0, 0);
}
static int hilfe(String t, char ch, int i, int a) {
if (t.length() == a) {
return i;
} else if (t.charAt(a) == ch) {
return hilfe(t, ch, i + 1, a + 1);
} else {
return hilfe(t, ch, i, a + 1);
}
}

如果索引变量到达末尾，则可以使用它返回0。否则，如果是字母或0，则返回1。

public class Main {
public static void main(String[] args) {
System.out.println(numberOf("Hello World-1234", 'o'));
}
private static int numberOf(String text, char characterToCount) {
if (!text.isEmpty()) {
return numberOf(text.substring(1), characterToCount) + (text.charAt(0) == characterToCount ? 1 : 0);
}
return 0;
}
}

EDIT：在没有substring的情况下实现

public class Main {
public static void main(String[] args) {
System.out.println(numberOf("Hello World-1234", 'o'));
}
private static int numberOf(String text, char characterToCount) {
if (text.isEmpty()) {
return 0;
}
char[] chars = text.toCharArray();
char[] newChars = new char[chars.length - 1];
System.arraycopy(chars, 1, newChars, 0, newChars.length);
return numberOf(new String(newChars), characterToCount) + (chars[0] == characterToCount ? 1 : 0);
}
}

相关内容

最新更新

热门标签：