Question

我正在尝试转换以下迭代代码：

int rows = 3;

    for (int i = 0; i <= rows; i++) 
    {
        for (int j = 0; j < i; j++)
        {
            System.out.print("*");
        }

        for (int j = 0; j < rows-i; j++)
        {
            System.out.print("-");
        }


        System.out.println();
    }

输出：

---
*--
**-
***

递归代码。这是一项任务。我创建了迭代代码，希望能够弄清楚如何将其直接转换为递归。以下是我的努力：

public void stringY(int star, int count){
        if (star > 0){
            System.out.print("*");
            stringY(star - 1, count);
        }
}

public void stringX(int dash,int count){
    if (dash == -1) {
        return;
    }else if (dash < count){
        System.out.print("-");
        stringX(dash - 1, count);
    } else if (dash == count){
        stringX(dash - 1, count);
    }
}


public void printPattern(int n) {
    if (n == -1){
        return;
    } else {
        printPattern(n-1);
        stringY(n, n);
        stringX(n, n);
        System.out.println();

    }

}

我的问题是，当我得到关于模式的“*”部分的输出时，我完全不知道如何获得模式的“ - ”部分。现在，这是一项任务，我不想要任何解决方案，但任何正确方向的指针都是绝对受欢迎的。我应该注意到我的两个要求是：1）我必须完全完成我的作业而不使用循环和2）我可以使用尽可能多的帮助方法，但主调用方法（printPattern）必须保持公共无效并且必须继续只接受整数。进一步说明：递归代码块中的其他两个方法是我创建的辅助方法。

Answer 1

首先让m =＆＃39; *＆＃39;打印并让n =＆＃39; - ＆＃39;打印

对于每次递归，将m递增1并将n递减1.

public static void main(String[] args) {
    printPattern(3);
}

public static void printPattern(int n) {
    printing(n, n);
}

//Variable size basically represent the number of columns
public static void printing(int n, int size) {
    //stop condition
    if(n == -1)
        return;

    //m is the number of * to print
    int m = size - n;
    printAsterisk(m);

    //n is the number of - to print
    printHyphen(n);

    System.out.println();

    printing(n - 1, size);
}

public static void printAsterisk(int m) {
    if(m == 0)
        return;
    System.out.print('*');
    printAsterisk(m - 1);
}

public static void printHyphen(int n) {
    if(n == 0)
        return;
    System.out.print('-');
    printHyphen(n - 1);
}

Answer 2

以这种方式思考，它们都只是循环做一些工作。所有你需要的理论上是一个递归函数，它自己调用直到传递的值。

void loop(int i, int till, Worker doThis) {
    if (i>=till) return;
    doThis.work(i);
    loop(i+1, till, doThis);
}

工人只是一个界面，

public interface Worker {
    void work(int index);
}

现在我们需要完成需要完成的工作。有三个循环，因此有三个调用loop函数。

final int rows = 3;
// outer loop
loop(0, rows+1, new Worker() {
    public void work(int index) {
        // Stars
        loop(0, index, new Worker() {
            public void work(int index) {
                System.out.print("*");
            }
        });
        // Dashes
        loop(0, rows-index, new Worker() {
            public void work(int index) {
                System.out.print("-");
            }
        });
        System.out.println();
    }
});

Answer 3

我首先提取STAR和DASH，

private static final String DASH = "-";
private static final String STAR = "*";

接下来，我会写一个方法来重复String给定次数。另外，我会使用StringBuilder（这里我以递归方式完成）

private static StringBuilder repeat(StringBuilder sb, String str, int n) {
    if (n > 0) {
        sb.append(str);
        repeat(sb, str, n - 1);
    }
    return sb;
}

接下来，基于StringBuilder

打印模式的私有递归方法

private static void printPattern(StringBuilder sb, int s) {
    System.out.println(sb);
    int p = sb.indexOf(DASH, s);
    if (p > -1) {
        sb.replace(p, p + DASH.length(), STAR);
        printPattern(sb, s + STAR.length());
    }
}

最后是公共方法

public static void printPattern(int n) {
    printPattern(repeat(new StringBuilder(), DASH, n), 0);
}

需要帮助将迭代过程转换为递归过程

3 个答案: