Ведение учета в рекурсивном методе Java

Question

Вот что я пытаюсь выполнить с помощью этой программы: рекурсивный метод, который проверяет, соответствует ли количество экземпляров подстроки указанному количеству экземпляров, возвращая логическое значение.

Вот проблема, которая возникает у меня с этим конкретным рекурсивным методом: я хотел бы иметь возможность перемещать счетчик внутри тела рекурсивного метода, однако я столкнулся с проблемой, которая возникает при сбросе счетчика при каждом рекурсивном вызове находится в теле метода. Единственный способ заставить его работать - это использование статической переменной counter, объявленной вне тела функции. Есть ли какая-либо другая техника, которую я могу использовать для определения счетчика метода в теле метода, чтобы этот метод мог действовать как «черный ящик»?

Спасибо за любые советы или идеи, которые вы можете предоставить.

public class strCopies {

    //count instances of part and whole equality
    static int count = 0;

    public static boolean copies(String whole, String part, int check)
    {

        //check if current string length is valid
        if(whole.length() < part.length())
        {
            //check if check parameter equals part instances
            if(count == check)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        //check if current string value is an instance of part 
        if(whole.substring(0, 3).equals(part))
        {
            count++;
        }

        //recursive call
        return copies(whole.substring(1), part, check);

    }

    public static void main(String[] args)
    {
        System.out.println(copies("dogcatdog", "cat", 2));
    }
}

Answer 1

Вы почти на месте: вам следует изменить значение переменной check на оставшееся количество совпадений , а не на запрашиваемое оригинальное число . Затем вы можете переписать метод, не сохраняя дополнительный счет, как показано ниже:

public static boolean copies(String whole, String part, int check)
{

    //check if current string length is valid
    if(whole.length() < part.length())
    {
        //check if check parameter equals part instances
        if(check == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    //check if current string value is an instance of part 
    if(whole.substring(0, 3).equals(part))
    {
        check--;
    }
    return return copies(whole.substring(1), part, check);
}

Answer 2

Не уверен, что делает ваш рекурсивный метод.Однако для поддержки счетчика вы можете передать его в качестве аргумента рекурсивному методу.

public boolean copies(String whole, String part, int check, int count) {

    // your code here....

    if(whole.substring(0, 3).equals(part))
    {
        count++;
    }

    //recursive call
    return copies(whole.substring(1), part, check, count);
}

Когда вы делаете первый вызов вашего copies метода, вам нужно передать 0 вашему count.

Answer 3

Вы можете передать счет в качестве аргумента рекурсивной функции, таким образом, он не будет «сброшен» при вызове метода.

public static boolean copies(String whole, String part, int check, int count)
{

    //check if current string length is valid
    if(whole.length() < part.length())
    {
        //check if check parameter equals part instances
        if(count == check)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    //check if current string value is an instance of part 
    if(whole.substring(0, 3).equals(part))
    {
        count++;
    }

    //recursive call
    return copies(whole.substring(1), part, check, count);

}

Answer 4

Вы можете добавить счетчик к параметрам метода следующим образом:

public class strCopies {

    public static boolean copies(String whole, String pargs, int check){
        return copies(whole, pargs, check, 0);
    }

    public static boolean copies(String whole, String part, int check, int count)
    {

        //check if current string length is valid
        if(whole.length() < part.length()) {
            //check if check parameter equals part instances
            if(count == check) {
                return true;
            }
            else {
                return false;
            }
        }

        //check if current string value is an instance of part
        if(whole.substring(0, 3).equals(part)) {
            count++;
        }

        //recursive call
        return copies(whole.substring(1), part, check, count);

    }

    public static void main(String[] args) {
        System.out.println(copies("dogcatdog", "dog", 2));
    }
}

Answer 5

public int countRecursive(String whole, String part){
    if(whole.length() < part.length()) return 0;
    if(part.length()==0) return -1; // ints can't express "Infinity" 
    // maybe you want to return -1 only if whole is not null, and something else if it is.       

    int count = 0;

    if(whole.substring(0, part.length()).equals(part))
        count = 1;
    return countRecursive(whole.substring(1), part) + count;
}

public boolean count(String whole, String part, int check){
    return countRecursive(whole, part) == check;
}

Обратите внимание, что это устраняет счетчик за счет создания целого ряда строк для каждого состояния.(Вы заменяете одно int на длину каждой заданной строки.) Но опять же, если вы хотите производительности, вам не следует использовать рекурсию для чего-то подобного.Простая петля for сделает намного лучше.

Answer 6

Простая версия:

Создать класс, содержащий счетчик. Инициализируйте это на своей главной странице. Передайте ссылку на функцию.

Другая идея:

Создайте одноэлементный класс со статическим счетчиком и вашей функцией X. Внутри его конструктора добавьте единицу к его счетчику и вызовите функцию X.

Затем вместо запуска вашей функции, как вы делали раньше, «создайте» этот класс, увеличив таким образом счетчик и вызвав функцию.

Удобно то, что вы можете наследовать этот класс и переопределять X в соответствии с тем, что вы выберете на последнем этапе, поэтому вы получаете этот общий класс, который рассчитывает на каждую активацию функции.