Question

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

如何打印1到10＆amp;通过使用单变量递归

来获得10到1

Answer 1

void print_recursive(int n) { 
    printf("%d\n", n);
    if (n < 10)
        print_recursive(n+1);
    printf("%d\n", n);
}

Answer 2

仅使用一个功能和一个变量：

void recurs(int num) {
    printf("%d\n", num);
    if (num < 10) {
        recurs(num + 1);
    }
    printf("%d\n", num);
}

int main() {
    recurs(1);
    return 0;
}

Answer 3

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

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

Answer 4

我将被推崇，我只知道它，但这是（a）解决方案。不是最好的，但你应该能够让自己变得更好。

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);
    }
}

Answer 5

这是一种偷偷摸摸的方式：

#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);
}

Answer 6

Javascript版本：

printNumber(1);

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

Answer 7

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

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

然后以-9.5作为开始调用recurfunc。

对我来说似乎很明显，答案是使用绝对值。

Answer 8

这是Ruby中的一个：

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

注意：在你断定Ruby是一个比Perl更糟糕的难以理解的混乱之前，让我向你保证：这是不是惯用的Ruby。惯用Ruby更像是

def recursive_count_up_and_down(n=1)
  return [] unless n<=10
  [n] +
  recursive_count_up_and_down(n + 1) +
  [n]
end

puts recursive_count_up_and_down

当然，Ruby是一种命令式语言，所以真的惯用它不会使用递归：

1.upto(10) do |i| puts i end
10.downto(1) do |i| puts i end

这是另一个不幸的是不使用递归的整洁的：

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

BTW：迄今为止所有解决方案，包括我的解决方案实际上都是作弊，因为从技术上讲，他们使用两个变量，因为

function foo {}

相当于

var foo = λ{}

因此，在上面的示例中，有两个变量：recursive_count_up_and_down和n。我们可以通过以默认的无点样式（例如在SK演算中）来消除这两者，但我会将其作为练习留给读者。（意思是我无法弄清楚:-)）

Answer 9

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

Answer 10

import java.util.Scanner;

public class PrintNumberFrom1To10 {

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);






}

}

你怎么打印1到10＆amp;通过使用单变量的递归来实现10到1

10 个答案: