How to print 1 to 100 without any looping using C#

Question

I am trying to print numbers from 1 to 100 without using loops, using C#. Any clues?

If this is for an assignment, what constructs have you been taught so far? This will help formulate answers. — JMD, Nov 27 '09 at 18:11
Have you got to recursion yet in the class or is this the first homework assignment? — The Matt, Nov 27 '09 at 18:14
Whew. This question was viewed 99 times when I found it. Glad I missed the corner case. — John, Nov 27 '09 at 18:23
@Not a real question voters: This is a real question. In case it's not clear, repharsed slightly: "How do I print the integers from 1 to 100 without using a loop? TIA." — jason, Nov 27 '09 at 18:25
Why has this been closed? This is a total valid & real question. — Sebastian P.R. Gingter, Nov 27 '09 at 18:36
It is a programming question however. I think there should be a definition of what is not a real question. We all started from somewhere remember. It think this community should be able to carry along programmers of different experience levels — Orson, Nov 27 '09 at 19:58
@Colour Blend: Agreed, as long as the person asking the question shows that they have at least made an effort to solve the problem first. Otherwise, they're learning nothing, but will pass their classes; then you and I end up maintaining the programs they've "written". That's not something I want to do - do you? — Ken White, Nov 27 '09 at 20:03
This question is not the same as fair beginner question such as "How do I 'unroll' a loop?" It's obviously a puzzle question. That's why there is debate over if it should be closed. — Ash, Dec 09 '09 at 12:31
http://stackoverflow.com/questions/2044033/display-numbers-from-1-to-100-without-loops-or-conditions Are you two in the same class? If so, why do one want it in C# while the other in Java — Christy John, Jan 12 '10 at 04:52

Pavel Minaev · Answer 1 · 2009-11-27T22:49:56.263

200

No loops, no conditionals, and no hardcoded literal output, aka "divide and conquer FTW" solution:

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

Alternative approach:

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

edited Nov 27 '09 at 22:49

answered Nov 27 '09 at 22:31

Pavel Minaev

99,783
25
219
289

3

This is innovative, but I see it as valuable as writing down 100 `WriteLine` statements :) – Gregory Pakosz Jan 11 '10 at 19:04
1

Clever, but then the next question will be how to print 1 to 101. How do you handle prime numbers? – Ozan Jan 12 '10 at 06:07
4

@Ozan: 1 to 101 is { P64(); P32(); P4(); P1(); }, 1 to 7 is { P4(); P2(); P1(); }. – Rasmus Faber Jan 12 '10 at 11:03
I love the power of two ladder approach for this. Very clever. I also like the lambda recursion model. But you should make your answer complete by also showing a self-attenuating closure. – LBushkin Jan 12 '10 at 16:27
@LBushkin: you can really think of the power of two ladder as or-ing together bit flags. 100 = 0b1100100, 64 = 0b1000000, 32 = 0b0100000, and 4 = 0b0000100, so 64 | 32 | 4 = 100. Coolness! – Juliet Jan 12 '10 at 20:41
@LBushkin: I'm not sure what you mean by "self-attenuating closure"; can you clarify (or maybe just post it as a separate answer)? – Pavel Minaev Jan 13 '10 at 02:03
This is amazing, Can you give some explanation on this please, I was just confused – Developer Nov 14 '12 at 13:23
@User Try stepping through it in the debugger, it should be pretty straightforward how it works there. – Pavel Minaev Nov 22 '12 at 00:50

Donnie · Answer 2 · 2017-11-10T23:02:16.070

66

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

edited Nov 10 '17 at 23:02

answered Nov 27 '09 at 18:11

Donnie

45,732
10
64
86

65

I'm sorry, this only prints 5 numbers, not all 100. – Adam Woś Jan 11 '10 at 18:52
7

I hope that Adam was joking in his comment. Of course it only prints 5 numbers. It's just shorthand. – Allain Lalonde Jan 12 '10 at 19:50
Of course you wouldn't need to write the shorthand if you make a code to write the output with a for loop, then copy the full output into the answer here... – Tadhg McDonald-Jensen Nov 08 '17 at 23:51

score 61 · Accepted Answer · answered Nov 27 '09 at 18:11

61

Recursion maybe?

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

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

answered Nov 27 '09 at 18:11

Caleb

9,272
38
30

28

Gratuitous "but first you have to understand recursion" comment. – Greg Beech Nov 27 '09 at 18:19
7

Recursion generally isn't considered a loop, even though its behaving similar to a loop. – Kyle Trauberman Nov 27 '09 at 22:15
Guess I need to read about Recursion. +1 for the help, thank you. – Leroy Jenkins Nov 27 '09 at 22:21
Although strictly not a loop, it's still using an incremental counter and a limit, so it's a clumsy loop ;) – Cecil Has a Name Nov 27 '09 at 22:43
3

A loop generally implies a mutable counter, this one doesn't have that (every invocation has its own "counter"). – Pavel Minaev Nov 27 '09 at 22:56
@Cecil: I don't think Noam Chomsky would think that – Jan 12 '10 at 00:58
Recursion is more general than a loop. – Thomas Eding Jan 12 '10 at 03:45
Couldn't you have simply called Main() recursively? – NTDLS Jan 15 '10 at 21:18
2

When I first started learning recursion I got a stack overflow in my brain. – Rich Jan 12 '11 at 22:48

score 46 · Answer 4 · answered Nov 27 '09 at 18:20

46

One more:

Console.WriteLine(
   String.Join(
      ", ", 
      Array.ConvertAll<int, string>(
         Enumerable.Range(1, 100).ToArray(), 
         i => i.ToString()
      )
   )
);

answered Nov 27 '09 at 18:20

João Angelo

56,552
12
145
147

1

`String.Join` is a nice solution, indeed! How didn't it come to my mind immediately? – fviktor Nov 27 '09 at 18:49
7

String.Join, Array.ConvertAll, Enumerable.Range and ToArray all use for/foreach constructs. You can't just encapsulate them and claim there is no looping! – Callum Rogers Jan 15 '10 at 23:21
@Callum, there are no loop constructs in my C# code as requested. :) This answer is all about plausible deniability and how to make the printed output look prettier using `String.Join`. – João Angelo Jan 18 '10 at 12:17

Jörg W Mittag · Answer 5 · 2017-03-14T23:28:14.517

14

using static IronRuby.Ruby;

class Print1To100WithoutLoopsDemo
{
    static void Main() => 
      CreateEngine().Execute("(1..100).each {|i| System::Console.write_line i }");
}

Hey, why not?

edited Mar 14 '17 at 23:28

answered Nov 27 '09 at 21:42

Jörg W Mittag

363,080
75
446
653

9

The answer to all C# questions. – Robert Fraser Jan 12 '10 at 00:05
1

Ruby's .each would be a loop, or? – gerrit May 14 '12 at 12:37
@gerrit: The Ruby Language Specification doesn't say how to implement `Range#each`. It is perfectly possible to implement it with recursion, for example. Besides, if you *really* want to dig down into the implementation, then even using a `for` loop counts as "without loop", since it will eventually be compiled into `GOTO`s anyway. – Jörg W Mittag May 14 '12 at 12:42
Hm, that makes the original question poorly defined then, or not? – gerrit May 14 '12 at 15:00
@gerrit: As most homework questions tend to be. Depending on what exactly the teacher is trying to teach, they probably expect the students to either use (tail) recursion or `GOTO` to solve this assignment, but: both are isomorphic to loops, so, saying you can't use anything which smells like a loop kind of defeats the purpose of this exercise. – Jörg W Mittag May 14 '12 at 17:40

score 12 · Answer 6 · answered Nov 27 '09 at 18:10

12

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

...Or would you have accepted a recursive solution?

EDIT: or you could do this and use a variable:

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

answered Nov 27 '09 at 18:10

FrustratedWithFormsDesigner

26,726
31
139
202

+1 for the recursive idea. Even though it's a bit abusive of the stack, it would work and it's only an assignment, presumably. – JMD Nov 27 '09 at 18:14
I haven't done C# in awhile, but couldn't you just just do Console.WriteLine( ++x ); instead of doing x += 1 before each line? (Obviously initializing the variable beforehand. – William Nov 27 '09 at 18:16
23

You could even use the variable the other 99 times! ;-) – Jim Ferrans Nov 27 '09 at 18:17
@Jim: yes, I'm a bit TOO quick with the copy/paste. I also had an idea to use events: Increase x, raise an event whose listener prints the event arg (which contains x). I see the recursive solution was the selected answer. I had hoped someone would submit a lambda solution. ;) – FrustratedWithFormsDesigner Nov 27 '09 at 18:38

jason · Answer 7 · 2009-11-27T18:19:14.630

Enumerable.Range(1, 100)
    .Select(i => i.ToString())
    .ToList()
    .ForEach(s => Console.WriteLine(s));

Not sure if this counts as the loop is kind of hidden, but if it's legit it's an idiomatic solution to the problem. Otherwise you can do this.

    int count = 1;
top:
    if (count > 100) { goto bottom; }
    Console.WriteLine(count++);
    goto top;
bottom:

Of course, this is effectively what a loop will be translated to anyway but it's certainly frowned upon these days to write code like this.

score 9 · Answer 8 · answered Jan 12 '10 at 04:29

No loops, no recursion, just a hashtable-like array of functions to choose how to branch:

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

dso · Answer 9 · 2009-11-27T19:04:26.587

Enumerable.Range(1, 100).ToList().ForEach(i => Console.WriteLine(i));

Here's a breakdown of what is happening in the above code:

Enumerable.Range returns the specified range of integral numbers as IEnumerator<Int32>
Enumerable.ToList<T> converts an IEnumerable<T> into a List<T>
List<T>.ForEach takes a lamdba function and invokes it for each item in the list

Performance Consideration

The ToList call will cause memory to be allocated for all items (in the above example 100 ints). This means O(N) space complexity. If this is a concern in your app i.e. if the range of integers can be very high, then you should avoid ToList and enumerate the items directly.

Unfortunately ForEach is not part of the IEnumerable extensions provided out of the box (hence the need to convert to List in the above example). Fortunately this is fairly easy to create:

static class EnumerableExtensions
{
    public static void ForEach<T>(this IEnumerable<T> items, Action<T> func)
    {
        foreach (T item in items)
        {
            func(item);
        }
    }
}

With the above IEnumerable extension in place, now in all the places where you need to apply an action to an IEnumerable you can simply call ForEach with a lambda. So now the original example looks like this:

Enumerable.Range(1, 100).ForEach(i => Console.WriteLine(i));

The only difference is that we no longer call ToList, and this results in constant (O(1)) space usage... which would be a quite noticeable gain if you were processing a really large number of items.

You can even pass a method group: `Enumerable.Range(1, 100).ForEach(Console.WriteLine);` — Jörg W Mittag, Dec 31 '10 at 21:15

score 8 · Answer 10 · edited Nov 19 '13 at 00:45

8

By the time I answer this, someone will already have it, so here it is anyway, with credit to Caleb:

void Main()
{
    print(0, 100);
}

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

edited Nov 19 '13 at 00:45

Undo

25,519
37
106
129

answered Nov 27 '09 at 18:31

Todd Richardson

1,119
1
11
22

score 8 · Answer 11 · answered Jan 15 '10 at 21:16

8

Just for the ugly literal interpretation:

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

(you can laugh now or later, or not)

answered Jan 15 '10 at 21:16

Mark Schultheiss

32,614
12
69
100

score 7 · Answer 12 · answered Nov 27 '09 at 18:11

I can think of two ways. One of them involves about 100 lines of code!

There's another way to reuse a bit of code several times without using a while/for loop...

Hint: Make a function that prints the numbers from 1 to N. It should be easy to make it work for N = 1. Then think about how to make it work for N = 2.

Wayne Conrad · Answer 13 · 2011-06-13T22:42:34.253

With regular expressions

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

   }
}

The output:

# => 1
# => 2
# ...
# => 99
# => 100

By which I guess you mean: "I'd give you as many +1's as the system would allow, but I'm sort of busy hammering a pencil into my brain with Knuth vol. 1. Thanks a lot." — Wayne Conrad, Jan 15 '10 at 23:53
@Luke, I guess it *is* important that insanity follow the rules. Better now? — Wayne Conrad, Jun 13 '11 at 22:43

score 5 · Answer 14 · answered Nov 27 '09 at 18:11

5

Method A:

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

Method B:

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

x(1);

answered Nov 27 '09 at 18:11

wallyk

56,922
16
83
148

1

I really don't want to downvote on such a silly question, but he did say using c#. :) – Donnie Nov 27 '09 at 18:12
2

@Donnie, this *seems* to be a homework question, which means users are encouraged to not give the exact code, but rather enough of a push in the right direction for the OP to figure it out, which I think @wallyk has done quite well. +1 – Brandon Nov 27 '09 at 18:14
@Brandon, fair enough. And I didn't downvote either, was just saying :) – Donnie Nov 27 '09 at 18:15

score 5 · Answer 15 · answered Jan 15 '10 at 21:48

5

Just LINQ it...

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

answered Jan 15 '10 at 21:48

Matthew Whited

22,160
4
52
69

wouldn't this be in turn translated into a while loop anyway? – Luke Jun 12 '11 at 19:29

score 2 · Answer 16 · answered Nov 27 '09 at 18:11

2

I can think two ways:

using 100 Console.WriteLine
using goto in a switch statement

answered Nov 27 '09 at 18:11

Jack

131,802
30
241
343

score 2 · Answer 17 · answered Jan 15 '10 at 21:34

A completely unnecessary method:

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

brendan · Answer 18 · 2009-11-27T19:58:46.427

1

public void Main()
{
  printNumber(1);
}

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

edited Nov 27 '09 at 19:58

answered Nov 27 '09 at 18:15

brendan

29,308
20
68
109

LOl posted a similar answer 8 seconds after you :( – Faisal Abid Nov 27 '09 at 18:16
2

shouldn't x be incremented? :D Stackoverflow! – Jack Nov 27 '09 at 18:25

score 1 · Answer 19 · answered Jun 12 '11 at 18:55

1

The cool and funny way:

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

answered Jun 12 '11 at 18:55

Shay Ben Moshe

1,298
3
12
27

score 1 · Answer 20 · edited Sep 01 '17 at 13:15

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

score 0 · Answer 21 · edited Nov 27 '09 at 18:31

0

This is more or less pseudo code I havent done c# in years, PS running on 1 hour of sleep so i might be wrong.

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

edited Nov 27 '09 at 18:31

Mark Carpenter

17,445
22
96
149

answered Nov 27 '09 at 18:15

Faisal Abid

8,900
14
59
91

2

You want `return;` instead of `break;` in your edge case. And `print()` isn't the correct function -- presumably you want `Console.WriteLine()`. – Daniel Pryden Nov 27 '09 at 18:59

score 0 · Answer 22 · answered Nov 27 '09 at 18:16

0

PrintNum(1);
private void PrintNum(int i)
{
   Console.WriteLine("{0}", i);
   if(i < 100)
   {
      PrintNum(i+1);
   } 
}

answered Nov 27 '09 at 18:16

Raj

1,742
1
12
17

score 0 · Answer 23 · answered Nov 27 '09 at 18:26

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

score 0 · Answer 24 · edited May 23 '17 at 12:09

0

My solution is in thread 2045637, which asks the same question for Java.

edited May 23 '17 at 12:09

Community

1
1

answered Jan 15 '10 at 22:09

David R Tribble

11,918
5
42
52

score 0 · Answer 25 · answered Sep 17 '18 at 06:37

Feeling a bit naughty posting this:

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

score 0 · Answer 26 · answered Dec 12 '18 at 17:04

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

score 0 · Answer 27 · answered Nov 20 '19 at 11:01

0

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

answered Nov 20 '19 at 11:01

Sonal

31
1

What is the diffenerence of this solution in comparison to the accepted answer? – slfan Nov 20 '19 at 11:23

Abdulsattar Mohammed · Answer 28 · 2011-09-28T13:40:24.763

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

You must notice that I'm NOT using recursion.

How to print 1 to 100 without any looping using C#

28 Answers28

Linked