Умножение объектов в массиве с другим объектом рекурсивно в Java

Question

Здравствуйте, я изучаю Java и, выполнив некоторые задания по изучению рекурсии, я давал себе несколько упражнений, чтобы выучить ее немного больше, но теперь я борюсь с некоторыми ..

Итак, главная проблема в том, что я не знаю, как я могу рекурсивно умножить каждый элемент в массиве, когда элементы в этом массиве являются объектами (возможно, в конце нет разницы, есть объекты или нет). Таким образом, упражнение, которое я дал себе, было: проверьте, находится ли 1/3 в данном массиве. Если да, то умножьте все в этом массиве на 2/1. Это фракция:

 private int numerator;      // Zaehler
 private int denominator;    // Nenner

        public Fraction ( int num, int denom )
        {
            if ( denom != 0 )
            {
                if ( denom < 0 )
                {
                    numerator = -num;
                    denominator = -denom;
                }
                else
                {
                    numerator = num;
                    denominator = denom;
                }
                reduce();
            }
            else
            {
                // error: division by zero
                throw new IllegalArgumentException();
            }
        }

        public Fraction()
        {
            numerator = 0;
            denominator = 1;
        }

        public Fraction( int num )
        {
            numerator = num;
            denominator = 1;
        }

Итак, я сделал это с помощью цикла for:

public static Fraction[] mulWithFor(Fraction[] arr)
        {
            for (int i = 0; i<arr.length; i++)
            {
                arr[i] = arr[i].multiply(new Fraction(2,1));
            }
            return arr;
        }

Но это не моя главная цель, я хочу сделать это рекурсивно, так что это был мой подход:

public static Fraction[] mulAus(Fraction[] arr, int i)
        {
            if (i>= 0 && i<arr.length)
            {
                rekurMul(arr,i);
                //return mulAus(rekurMul(arr,i-1));
            }
            return arr;
        }

        public static Fraction rekurMul(Fraction[] arr, int i)
        {
            if (i>= 0 && i<arr.length)
            {
                return arr[i].multiply(new Fraction(2,1));
                return arr[i].multiply(new Fraction(2, 1)); // Does Not Work!!!
            }
            throw new IndexOutOfBoundsException();
        }

Может быть, есть кто-то, кто может мне помочь! Спасибо за внимание.

ОК. Спасибо @ Chaï Sarfati, а также другим, которые пытаются мне помочь. Теперь я знаю, как умножать рекурсивные вещи в массиве! Я использовал методы из @ Chaï Sarfati, но написал альтернативный метод для его «oneThirdIsPresent», который также является рекурсивным методом: так что теперь мой рабочий код выглядит следующим образом

 public static Fraction[] mulAus(Fraction[] arr)
        {
            if(contains(arr,arr.length-1,new Fraction(1,3)))
            {
                rekurMul(arr,0);
                return arr;
            }
            throw new IllegalArgumentException("1/3 does not exist in the Input-Array");
        }

        public static void rekurMul(Fraction[] arr, int i)
        {
            if(i == arr.length)
            {
                return ;
            }
            arr[i] = arr[i].multiply(new Fraction(2,1));
            rekurMul(arr,i+1);
        }

Метод проверки, если 1/3 существует в данном массиве.

public static boolean contains(Fraction[] arr, int i, Fraction x)
        {
            if (i>= 0 && i < arr.length)
            {
                if (arr[i].equals(x))
                { return true;}
                else
                { return contains(arr, i-1,x); }
            }
            return false;
        }

Я надеюсь, что другие люди смогут извлечь уроки из кода. Может быть, есть лучшие решения, но я только начинаю программировать, поэтому пока не знаю их. Пока

Answer 1

Вот краткий пример только части рекурсивного умножения:

public static void main(String[] args)
{
    Fraction[] fractions = new Fraction[] {new Fraction(1,2), new Fraction(2,3), new Fraction(3,1)};

    System.out.println("Fractions:");
    for(Fraction f: fractions)
    {
        System.out.println(f);
    }

    System.out.println("Multiplying array by 2...");
    Fraction.mulAus(fractions, new Fraction(2, 1));
    for(Fraction f: fractions)
    {
        System.out.println(f);
    }
}

Модифицированный класс дроби (код умножения внизу):

public class Fraction
{

        private int numerator;      // Zaehler
        private int denominator;    // Nenner

        public Fraction(int num, int denom)
        {
            if (denom != 0)
            {
                if (denom < 0)
                {
                    numerator = -num;
                    denominator = -denom;
                }
                else
                {
                    numerator = num;
                    denominator = denom;
                }
                reduce();
            }
            else
            {
                // error: division by zero
                //throw new IllegalArgumentException();
            }
        }

        private void reduce()
        {
            // ... 
        }

        public Fraction()
        {
            numerator = 0;
            denominator = 1;
        }

        public Fraction(int num)
        {
            numerator = num;
            denominator = 1;
        }

        public String toString()
        {
            return numerator + " / " + denominator;
        }

        public void MultiplyBy(Fraction F)
        {
            if (F != null)
            {
                numerator = numerator * F.numerator;
                denominator = denominator * F.denominator;
                reduce();
            }
        }

        public static void mulAus(Fraction[] arr, Fraction F)
        {
            if(arr != null && F != null)
            {
                rekurMul(arr, 0, F);
            }
        }

        private static void rekurMul(Fraction[] arr, int i, Fraction F)
        {
            arr[i].MultiplyBy(F);
            if (i < (arr.length - 1))
            {
                rekurMul(arr, ++i, F);
            }
        }

}

Вывод:

Answer 2

Предположим, у вас есть multiplyBy(Fraction f) метод, который правильно работает в вашем Fraction классе. Более того, будет лучше (более читабельно, с большей экономией времени и пространства) делать это итеративно. Ради примера я бы сделал так:

Первое определение:

private static boolean oneThirdIsPresent(Fraction[] arr){
    for (int i = 0; i < arr.length; i++) {
        if(arr[i].numerator == 1 && arr[i].denominator == 3) {
            return true;
        }
    }
    return false;
}

private static void recursivelyMultBy2(Fraction[] arr, int index){
    if(index == arr.length){
        return;
    }
    arr[index] = arr[index].multiplyBy(new Fraction(2));
    recursivelyMultBy2(arr, index+1);
}

Чтобы окончательно решить:

public static void multBy2IfOneThirdIsPresent(Fraction[] arr){
    if(oneThirdIsPresent(arr)){
        recursivelyMultBy2(arr, 0);
    }else{
        return;
    }
}