C# 如何使用C在没有任何循环的情况下打印1到100#_C#_Recursion

C# 如何使用C在没有任何循环的情况下打印1到100#

c# recursion

C# 如何使用C在没有任何循环的情况下打印1到100#,c#,recursion,C#,Recursion,我正在尝试打印从1到100的数字，而不使用循环，使用C#。有什么线索吗 Console.WriteLine('1'); Console.WriteLine('2'); ... Console.WriteLine('100'); …或者您会接受递归解决方案吗编辑：或者您可以执行此操作并使用变量： int x = 1; Console.WriteLine(x); x+=1; Console.WriteLine('2'); x+=1; ... x+=1 Console.WriteLine('100

我正在尝试打印从1到100的数字，而不使用循环，使用C#。有什么线索吗

Console.WriteLine('1');
Console.WriteLine('2');
...
Console.WriteLine('100');

…或者您会接受递归解决方案吗

编辑：或者您可以执行此操作并使用变量：

int x = 1;
Console.WriteLine(x);
x+=1;
Console.WriteLine('2');
x+=1;
...
x+=1
Console.WriteLine('100');

我可以想出两种方法。其中一个涉及大约100行代码

还有另一种方法可以多次重用一段代码，而不用使用while/for循环

提示：制作一个打印从1到N的数字的函数。对于N=1，应该很容易使其工作。然后考虑如何使其在N=2时工作。

我可以考虑两种方法：

Console.Out.WriteLine('1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100');

使用100
```
Console.WriteLine
```
在
```
开关
```
语句中使用
```
goto
```

方法A：

Console.WriteLine('1');
Console.WriteLine('print 2');
Console.WriteLine('print 3');
...
Console.WriteLine('print 100');

方法B：

func x (int j)
{
  Console.WriteLine(j);
  if (j < 100)
     x (j+1);
}

x(1);

func x（int j）
{
控制台写入线（j）；
如果（j<100）
x（j+1）；
}
x（1）；

可能是递归

public static void PrintNext(i) {
    if (i <= 100) {
        Console.Write(i + " ");
        PrintNext(i + 1);
    }
}

public static void Main() {
    PrintNext(1);
}

publicstaticvoidprintnext（一）{
如果（i）
不确定这是否算作是某种隐藏的循环，但如果它是合法的，这是解决问题的惯用方法。否则你可以这样做
    int count = 1;
top:
    if (count > 100) { goto bottom; }
    Console.WriteLine(count++);
    goto top;
bottom:

当然，这实际上是一个循环无论如何都会被转换成的东西，但现在这样编写代码肯定是不受欢迎的。
public void Main（）
public void Main()
{
  printNumber(1);
}

private void printNumber(int x)
{
  Console.WriteLine(x.ToString());
  if(x<101)
  {
    x+=1;
    printNumber(x);
  }
}

{
打印号码（1）；
}
专用无效打印编号（int x）
{
Console.WriteLine（x.ToString（））；
如果（x这或多或少是伪代码，我已经好几年没有做过c了，PS是在睡眠1小时的情况下运行的，所以我可能是错的
int i = 0;

public void printNum(j){       
    if(j > 100){
        break;
    } else {
        print(j);
        printNum(j + 1);
    }
}
public void main(){
    print(i);
    printNum(i + 1);       
}

PrintNum（1）；
私有void PrintNum（int i）
{
Console.WriteLine（“{0}”，i）；
如果（i<100）
{
PrintNum（i+1）；
} 
}
还有一个：
Console.WriteLine(
   String.Join(
      ", ", 
      Array.ConvertAll<int, string>(
         Enumerable.Range(1, 100).ToArray(), 
         i => i.ToString()
      )
   )
);

Console.WriteLine(
串，加入(
", ", 
Array.ConvertAll(
可枚举的.Range（1100）.ToArray（），
i=>i.ToString（）
)
)
);

下面是上述代码中发生的情况的细分：

返回指定的整数范围作为IEnumerator
将IEnumerable转换为列表
获取一个lamdba函数并为列表中的每个项调用它

性能考虑因素
ToList调用将导致为所有项目分配内存（在上面的示例中为100整数）。这意味着O（N）空间复杂度。如果这是应用程序中的一个问题，即如果整数的范围可能非常大，则应避免ToList并直接枚举项目
不幸的是，ForEach不是现成提供的IEnumerable扩展的一部分（因此需要在上面的示例中转换为List）。幸运的是，这很容易创建：
static class EnumerableExtensions
{
    public static void ForEach<T>(this IEnumerable<T> items, Action<T> func)
    {
        foreach (T item in items)
        {
            func(item);
        }
    }
}

唯一的区别是我们不再调用ToList，这会导致恒定的（O（1））空间使用率…如果您处理大量的项，这将是一个非常明显的好处。
命名空间控制台应用程序2{
namespace ConsoleApplication2 {
    class Program {
        static void Main(string[] args) {
            Print(Enumerable.Range(1, 100).ToList(), 0);
            Console.ReadKey();

        }
        public static void Print(List<int> numbers, int currentPosition) {
            Console.WriteLine(numbers[currentPosition]);
            if (currentPosition < numbers.Count - 1) {
                Print(numbers, currentPosition + 1);
            }
        }
    }
}

班级计划{
静态void Main（字符串[]参数）{
打印（可枚举的.Range（1100）.ToList（），0）；
Console.ReadKey（）；
}
公共静态无效打印（列表编号，int currentPosition）{
Console.WriteLine（编号[当前位置]）；
if（当前位置<数字计数-1）{
打印（数字，当前位置+1）；
}
}
}
}
当我回答这个问题时，有人已经拥有了它，所以不管怎样，它就在这里，归功于Caleb：
void Main()
{
    print(0, 100);
}

public void print(int x, int limit)
{
    Console.WriteLine(++x);
    if(x != limit)
        print(x, limit);
}

嘿，为什么不呢？
没有循环，没有条件，也没有硬编码文字输出，即“分而治之FTW”解决方案：
class P
{
    static int n;

    static void P1() { System.Console.WriteLine(++n); }

    static void P2() { P1(); P1(); }

    static void P4() { P2(); P2(); }

    static void P8() { P4(); P4(); }

    static void P16() { P8(); P8(); }

    static void P32() { P16(); P16(); }

    static void P64() { P32(); P32(); }

    static void Main() { P64(); P32(); P4(); }
}

备选办法：
using System;

class C
{
    static int n;

    static void P() { Console.WriteLine(++n); }

    static void X2(Action a) { a(); a(); }

    static void X5(Action a) { X2(a); X2(a); a(); }

    static void Main() { X2(() => X5(() => X2(() => X5(P)))); }
}

没有循环，没有递归，只有一个类似哈希表的函数数组，可以选择如何进行分支：
using System;
using System.Collections.Generic;

namespace Juliet
{
    class PrintStateMachine
    {
        int state;
        int max;
        Action<Action>[] actions;

        public PrintStateMachine(int max)
        {
            this.state = 0;
            this.max = max;
            this.actions = new Action<Action>[] { IncrPrint, Stop };
        }

        void IncrPrint(Action next)
        {
            Console.WriteLine(++state);
            next();
        }

        void Stop(Action next) { }

        public void Start()
        {
            Action<Action> action = actions[Math.Sign(state - max) + 1];
            action(Start);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            PrintStateMachine printer = new PrintStateMachine(100);
            printer.Start();
            Console.ReadLine();
        }
    }
}

使用系统；
使用System.Collections.Generic；
朱丽叶
{
类打印机
{
int状态；
int max；
行动[]行动；
公共PrintStateMachine（int max）
{
该状态=0；
this.max=max；
this.actions=新操作[]{IncrPrint，Stop}；
}
无效IncrPrint（下一步操作）
{
Console.WriteLine（++状态）；
next（）；
}
无效停止（下一步操作）{}
公开作废开始（）
{
动作动作=动作[数学符号（状态-最大）+1]；
行动（启动）；
}
}
班级计划
{
静态void Main（字符串[]参数）
{
PrintStateMachine打印机=新的PrintStateMachine（100）；
printer.Start（）；
Console.ReadLine（）；
}
}
}
使用正则表达式
using System.Text.RegularExpressions;

public class Hello1
{
   public static void Main()
   {

      // Count to 128 in unary
      string numbers = "x\n";
      numbers += Regex.Replace(numbers, "x+\n", "x$&");
      numbers += Regex.Replace(numbers, "x+\n", "xx$&");
      numbers += Regex.Replace(numbers, "x+\n", "xxxx$&");
      numbers += Regex.Replace(numbers, "x+\n", "xxxxxxxx$&");
      numbers += Regex.Replace(numbers, "x+\n", "xxxxxxxxxxxxxxxx$&");
      numbers += Regex.Replace(numbers, "x+\n", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx$&");
      numbers += Regex.Replace(numbers, "x+\n", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx$&");

      // Out of 1..128, select 1..100
      numbers = Regex.Match(numbers, "(.*\n){100}").Value;

      // Convert from unary to decimal
      numbers = Regex.Replace(numbers, "x{10}", "<10>");
      numbers = Regex.Replace(numbers, "x{9}", "<9>");
      numbers = Regex.Replace(numbers, "x{8}", "<8>");
      numbers = Regex.Replace(numbers, "x{7}", "<7>");
      numbers = Regex.Replace(numbers, "x{6}", "<6>");
      numbers = Regex.Replace(numbers, "x{5}", "<5>");
      numbers = Regex.Replace(numbers, "x{4}", "<4>");
      numbers = Regex.Replace(numbers, "x{3}", "<3>");
      numbers = Regex.Replace(numbers, "x{2}", "<2>");
      numbers = Regex.Replace(numbers, "x{1}", "<1>");
      numbers = Regex.Replace(numbers, "(<10>){10}", "<100>");
      numbers = Regex.Replace(numbers, "(<10>){9}", "<90>");
      numbers = Regex.Replace(numbers, "(<10>){8}", "<80>");
      numbers = Regex.Replace(numbers, "(<10>){7}", "<70>");
      numbers = Regex.Replace(numbers, "(<10>){6}", "<60>");
      numbers = Regex.Replace(numbers, "(<10>){5}", "<50>");
      numbers = Regex.Replace(numbers, "(<10>){4}", "<40>");
      numbers = Regex.Replace(numbers, "(<10>){3}", "<30>");
      numbers = Regex.Replace(numbers, "(<10>){2}", "<20>");
      numbers = Regex.Replace(numbers, "(<[0-9]{3}>)$", "$1<00>");
      numbers = Regex.Replace(numbers, "(<[0-9]{2}>)$", "$1<0>");
      numbers = Regex.Replace(numbers, "<([0-9]0)>\n", "$1\n");
      numbers = Regex.Replace(numbers, "<([0-9])0*>", "$1");

      System.Console.WriteLine(numbers);

   }
}

只是为了一个丑陋的字面解释：
Console.WriteLine("numbers from 1 to 100 without using loops, ");

（你可以现在或以后笑，也可以不笑）
一种完全不必要的方法：
int i = 1;
System.Timers.Timer t = new System.Timers.Timer(1);
t.Elapsed += new ElapsedEventHandler(
  (sender, e) => { if (i > 100) t.Enabled = false; else Console.WriteLine(i++); });
t.Enabled = true;
Thread.Sleep(110);

就这样吧
Console.WriteLine(Enumerable.Range(1, 100)
                            .Select(s => s.ToString())
                            .Aggregate((x, y) => x + "," + y));

我的解决方案是线程，它对Java提出了同样的问题。
酷而有趣的方式：
static void F(int[] array, int n)
{
    Console.WriteLine(array[n] = n);
    F(array, n + 1);
}
static void Main(string[] args)
{
    try { F(new int[101], 1); }
    catch (Exception e) { }
}

类程序
{
静态计时器s=新计时器（）；
静态int i=0；
静态void Main（字符串[]参数）
{
s、 运行时间+=重新启动；
s、 Start（）；
Console.ReadLine（）；
}
静态无效重新启动（对象发送器，ElapsedEventArgs e）
{
s、 处置（）；
如果（i<100）
{
控制台写入线（++i）；
s=新定时器（1）；
s、 运行时间+=重新启动；
s、 Start（）；
}
}
}

你一定注意到我没有使用递归。
觉得有点淘气发布以下内容：
   private static void Main()
    {
        AppDomain.CurrentDomain.FirstChanceException += (s, e) =>
        {
            var frames = new StackTrace().GetFrames();
            Console.Write($"{frames.Length - 2} ");
            var frame = frames[101];
        };

        throw new Exception();
    }

static void Main（字符串[]args）
{
打印（0）；
}
公共静态无效打印（int i）
{
如果（i>=0&&ii如果这是一个作业，那么到目前为止你学过什么结构？这将有助于形成答案。你在课堂上还需要递归吗？还是这是第一个家庭作业？呼。这个问题在我找到它时被浏览了99次。很高兴我错过了角落案例。为什么这个问题被关闭了？这是一个完全有效且真实的问题问题。你们两个在同一个班吗？如果是的话，为什么一个用C#而另一个用C#
# => 1
# => 2
# ...
# => 99
# => 100

Console.WriteLine("numbers from 1 to 100 without using loops, ");

int i = 1;
System.Timers.Timer t = new System.Timers.Timer(1);
t.Elapsed += new ElapsedEventHandler(
  (sender, e) => { if (i > 100) t.Enabled = false; else Console.WriteLine(i++); });
t.Enabled = true;
Thread.Sleep(110);

Console.WriteLine(Enumerable.Range(1, 100)
                            .Select(s => s.ToString())
                            .Aggregate((x, y) => x + "," + y));

static void F(int[] array, int n)
{
    Console.WriteLine(array[n] = n);
    F(array, n + 1);
}
static void Main(string[] args)
{
    try { F(new int[101], 1); }
    catch (Exception e) { }
}

class Program
{
    static int temp = 0;

    public static int a()
    {
        temp = temp + 1;

        if (temp == 100)
        {
            Console.WriteLine(temp);
            return 0;
        }

        else
            Console.WriteLine(temp);

        Program.a();
        return 0;
    }

    public static void Main()
    {
        Program.a();
        Console.ReadLine();
    }
}

class Program
{
    static Timer s = new Timer();
    static int i = 0;
    static void Main(string[] args)
    {
        s.Elapsed += Restart;
        s.Start();
        Console.ReadLine();
    }
    static void Restart(object sender, ElapsedEventArgs e)
    {
        s.Dispose();
        if (i < 100)
        {
            Console.WriteLine(++i);
            s = new Timer(1);
            s.Elapsed += Restart;
            s.Start();
        }
    }
}

   private static void Main()
    {
        AppDomain.CurrentDomain.FirstChanceException += (s, e) =>
        {
            var frames = new StackTrace().GetFrames();
            Console.Write($"{frames.Length - 2} ");
            var frame = frames[101];
        };

        throw new Exception();
    }

    [Test]
    public void PrintNumbersNoLoopOrRecursionTest()
    {
        var numberContext = new NumberContext(100);

        numberContext.OnNumberChange += OnNumberChange(numberContext);
        numberContext.CurrentNumber = 1;
    }

    OnNumberChangeHandler OnNumberChange(NumberContext numberContext)
    {
        return (o, args) =>
        {
            if (args.Counter > numberContext.LastNumber)
                return;

            Console.WriteLine(numberContext.CurrentNumber);

            args.Counter += 1;
            numberContext.CurrentNumber = args.Counter;
        };
    }


public delegate void OnNumberChangeHandler(object source, OnNumberChangeEventArgs e);
public class NumberContext
{
    public NumberContext(int lastNumber)
    {
        LastNumber = lastNumber;
    }

    public event OnNumberChangeHandler OnNumberChange;
    private int currentNumber;
    public int CurrentNumber
    {
        get { return currentNumber; }
        set {
            currentNumber = value;
            OnNumberChange(this, new OnNumberChangeEventArgs(value));
        }
    }

    public int LastNumber { get; set; }

    public class OnNumberChangeEventArgs : EventArgs
    {
        public OnNumberChangeEventArgs(int counter)
        {
            Counter = counter;
        }

        public int Counter { get; set; }
    }

static void Main(string[] args)
        {

            print(0);
        }

        public static void print(int i)
        {
            if (i >= 0 && i<=10)
            {

                i = i + 1;
                Console.WriteLine(i + " ");
                print(i);
            }
}