Comment imprimer de 1 à 100, sans aucune boucle à l'aide de C#

Pas de boucles, pas de conditions, et pas codé en dur littérale de sortie, aka "diviser et conquérir 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(); }
}

Approche Alternative:

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

Un de plus:

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

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

...Ou serait vous avez accepté une solution récursive?

EDIT: ou vous pouvez le faire et utiliser une variable:

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

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

Voici une ventilation de ce qui se passe dans le code ci-dessus:

• Énumérable.Gamme les retours de la plage spécifiée de l'ensemble des numéros de la IEnumerator<Int32>
• Énumérable.ToList<T> convertit un IEnumerable<T> dans une List<T>
• Liste<T>.ForEach prend un lamdba fonction et l'invoque pour chaque élément dans la liste

Facteur De Performance

La ToList appel va causer de mémoire à allouer pour tous les articles (dans l'exemple ci-dessus de 100 ints). Cela signifie que O(N) l'espace de la complexité. Si c'est un souci dans votre application, c'est à dire si la plage des entiers peuvent être très élevés, alors vous devriez éviter ToList et énumérer les éléments directement.

Malheureusement ForEach ne fait pas partie de l'interface IEnumerable extensions fournis à l'extérieur de la boîte (d'où le besoin de les convertir à la Liste dans l'exemple ci-dessus). Heureusement, il est assez facile de créer:

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

Ci-dessus IEnumerable extension en place, maintenant dans tous les endroits où vous avez besoin d'appliquer une action à un IEnumerable, vous pouvez simplement appeler ForEach avec un lambda. Alors maintenant l'exemple d'origine ressemble à ceci:

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

La seule différence est que nous n'avons plus appel ToList, ce qui est constant (O(1)) l'utilisation de l'espace... ce qui serait tout à fait perceptible gain si vous étiez le traitement d'un très grand nombre d'éléments.

Juste pour le laid interprétation littérale:

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

(vous pouvez rire maintenant ou plus tard, ou pas)

Je pense, de deux façons. L'un d'eux consiste à environ 100 lignes de code!

Il y a une autre façon de réutiliser un peu de code plusieurs fois sans l'aide d'un certain temps/pour la boucle...

Astuce: Faire une fonction qui affiche les nombres de 1 à N. Il devrait être facile de le faire fonctionner pour N = 1. Alors pensez à la façon de le faire travailler pour N = 2.

Méthode A:

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

Méthode B:

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

Je pense, de deux façons:

• à l'aide de 100 Console.WriteLine
• à l'aide de goto dans un switch déclaration

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

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

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

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

Vous devez remarquer que je suis PAS en utilisant la récursivité.

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