Recursion 如何使用单变量递归打印1到10和10到1

我正在准备明天的面试-我需要这个问题的答案：

---

如何通过使用单变量递归打印1到10和10到1您应该能够自己解决这个问题

class Program
{
    static void Main(string[] args)
    {
        printNumDown(10);
    }

    static void printNumDown(int num)
    {
        Console.WriteLine(num.ToString());
        if (num > 1)
            printNumDown(num - 1);
        else
            printNumUp(num + 1);
    }

    static void printNumUp(int num)
    {
        Console.WriteLine(num.ToString());
        if (num < 10)
            printNumUp(num + 1);
    }
}

---

提示：创建一个以10为参数的方法，然后打印参数并用9调用自己。

您应该能够自己解决这个问题

class Program
{
    static void Main(string[] args)
    {
        printNumDown(10);
    }

    static void printNumDown(int num)
    {
        Console.WriteLine(num.ToString());
        if (num > 1)
            printNumDown(num - 1);
        else
            printNumUp(num + 1);
    }

    static void printNumUp(int num)
    {
        Console.WriteLine(num.ToString());
        if (num < 10)
            printNumUp(num + 1);
    }
}

---

提示：创建一个以10为参数的方法，然后打印参数并用9调用自己。

我会被否决，我知道，但这里有一个解决方案。不是最好的，但你自己应该能做得更好

class Program
{
    static void Main(string[] args)
    {
        printNumDown(10);
    }

    static void printNumDown(int num)
    {
        Console.WriteLine(num.ToString());
        if (num > 1)
            printNumDown(num - 1);
        else
            printNumUp(num + 1);
    }

    static void printNumUp(int num)
    {
        Console.WriteLine(num.ToString());
        if (num < 10)
            printNumUp(num + 1);
    }
}

---

我会被否决的，我知道，但这里有一个解决办法。不是最好的，但你自己应该能做得更好

class Program
{
    static void Main(string[] args)
    {
        printNumDown(10);
    }

    static void printNumDown(int num)
    {
        Console.WriteLine(num.ToString());
        if (num > 1)
            printNumDown(num - 1);
        else
            printNumUp(num + 1);
    }

    static void printNumUp(int num)
    {
        Console.WriteLine(num.ToString());
        if (num < 10)
            printNumUp(num + 1);
    }
}

这里有一个鬼鬼祟祟的方法：

#include <stdio.h>

static void recur_up (int n) {
    if (n > 1)
        recur_up (n - 1);
    printf ("%d\n", n);
}

static void recur_down (int n) {
    printf ("%d\n", n);
    if (n > 1)
        recur_down (n - 1);
}

int main (void) {
    recur_up (10);
    recur_down (10);
    return 0;
}

向下比向上更优雅，因为你可以用一个函数：

static void recur_both (int n) {
    printf ("%d\n", n);
    if (n > 1)
        recur_down (n - 1);
    printf ("%d\n", n);
}

这里有一个鬼鬼祟祟的方法：

#include <stdio.h>

static void recur_up (int n) {
    if (n > 1)
        recur_up (n - 1);
    printf ("%d\n", n);
}

static void recur_down (int n) {
    printf ("%d\n", n);
    if (n > 1)
        recur_down (n - 1);
}

int main (void) {
    recur_up (10);
    recur_down (10);
    return 0;
}

向下比向上更优雅，因为你可以用一个函数：

static void recur_both (int n) {
    printf ("%d\n", n);
    if (n > 1)
        recur_down (n - 1);
    printf ("%d\n", n);
}

只有一个函数和一个变量：

只有一个函数和一个变量：

Javascript版本：

printNumber(1);

function printNumber(num){
  document.write(num);
  if (num < 10) 
     printNumber(num + 1);
  document.write(num);
}

Javascript版本：

printNumber(1);

function printNumber(num){
  document.write(num);
  if (num < 10) 
     printNumber(num + 1);
  document.write(num);
}

这里有一个Ruby版本：

puts (r = ->n=1 { if n<=10 then [n] + r.(n+1) + [n] else [] end }).()

不幸的是，这里还有另一个不使用递归的简洁方法：

puts Array.new(20) {|i| if i < 10 then i+1 else 20-i end }

相当于

var foo = λ{}

所以，在我上面的例子中，有两个变量：递归的_count _up _和_down以及n。我们可以通过在SK演算中以一种默契的无点风格来消除这两种情况，但我将把它作为练习留给读者。意思是我无法理解：-

这是一个Ruby版本：

puts (r = ->n=1 { if n<=10 then [n] + r.(n+1) + [n] else [] end }).()

不幸的是，这里还有另一个不使用递归的简洁方法：

puts Array.new(20) {|i| if i < 10 then i+1 else 20-i end }

相当于

var foo = λ{}

---

所以，在我上面的例子中，有两个变量：递归的_count _up _和_down以及n。我们可以通过在SK演算中以一种默契的无点风格来消除这两种情况，但我将把它作为练习留给读者。意思是我搞不懂：-

你们为什么都这么难对付？在伪代码中：

function recurfunc(n) {
    if (n < 10) {
    echo (-1 * (floor(abs(n)) - 10));
        recurfunc(n+1);
    }
}

然后以-9.5作为起点调用recurfunc

---

对我来说，答案显然是用绝对值。

为什么你们都这么难？在伪代码中：

function recurfunc(n) {
    if (n < 10) {
    echo (-1 * (floor(abs(n)) - 10));
        recurfunc(n+1);
    }
}

#include<stdio.h>
void c(int n)
{
   static int i;
   if(i<n)
   {
     i++;
     printf("%d",i);
     c(n);
   }
}
int main()
{
  c(5);
}

然后以-9.5作为起点调用recurfunc

---

对我来说，答案显然是使用绝对值。

导入java.util.Scanner

#include<stdio.h>
void c(int n)
{
   static int i;
   if(i<n)
   {
     i++;
     printf("%d",i);
     c(n);
   }
}
int main()
{
  c(5);
}

公共类打印编号从1到10{

public static void printNumber(int num){


    if(num<=10){


    System.out.println(num);


    printNumber(num+1);


    }
}

public static void main(String[] args) {


    System.out.println("Enter Your Number: ");


    Scanner sc = new Scanner(System.in);



    int num = sc.nextInt();




    printNumber(num);






}

---

}导入java.util.Scanner

公共类打印编号从1到10{

public static void printNumber(int num){


    if(num<=10){


    System.out.println(num);


    printNumber(num+1);


    }
}

public static void main(String[] args) {


    System.out.println("Enter Your Number: ");


    Scanner sc = new Scanner(System.in);



    int num = sc.nextInt();




    printNumber(num);






}

---

---

}

如果你自己也搞不清楚，在这里问这个问题是在面试中作弊。这是一个编程工作的面试吗？@Lerxst:还有什么可能？如果是一个建筑工作的面试，这个问题不太可能出现+1呵呵@Michael，是的，这主意不错！如果你自己也搞不清楚，在这里问这个问题是在面试中作弊。这是一个编程工作的面试吗？@Lerxst:还有什么可能？如果是一个建筑工作的面试，这个问题不太可能出现+1呵呵@Michael，是的，这是个不错的主意！我需要这个问题的答案。我不需要这方面的帮助，但非常具体地说，我需要答案。所以在我看来你不应该被否决。我需要这个问题的答案。我不需要这方面的帮助，但非常具体地说，我需要答案。在我看来，你不应该被否决。用一个函数还是有可能的。为什么，是的，这是以硬编码为代价的，上限不太灵活。但是规范没有要求一个函数，只要求递归和一个变量：-用一个函数仍然可以做到这一点为什么，是的，是以硬编码为代价的上限不太灵活。但是规范没有要求一个函数，只有递归和一个变量：-除非我完全失明，否则不会再次倒计时。注意，他有两次printf。它利用了上下计数的对称性，所以只需要循环1-10@阿拉斯泰尔，你可以试着运行它。虽然他使用了%n而不是%d，并且忘记了换行符，但这个概念确实有效；杰瑞，我现在明白了。很不错的。我为缺乏信心而道歉：@Michael:谢谢你注意到printf中的问题。现在它被更正了。除非我完全失明，否则这不会再次倒计时。注意，他有两次printf。它利用了上下计数的对称性，所以只需要循环1-10@阿拉斯泰尔，你可以试着运行它。虽然他使用了%n而不是%d，并且忘记了换行符，但这个概念确实有效；杰瑞，我现在明白了。很不错的。我为缺乏信心而道歉：@Michael:谢谢你注意到printf中的问题。现在已更正。代码golfed:f1；函数fx{d=document；d.writex；ifxcode golfed:f1；函数fx{d=document；d.writex；ifx