Как напечатать от 1 до 100 без зацикливания, используя C #

Question

Я пытаюсь напечатать числа от 1 до 100 без использования циклов, используя C #. Любые подсказки?

Answer 1

Без циклов, без условных выражений и без жестко закодированного литерального вывода, известного как «разделяй и властвуй»:

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

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

Answer 3

Рекурсия может быть?

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

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

Answer 4

Еще один:

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

Answer 5

using static IronRuby.Ruby;

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

Эй, а почему бы и нет?

Answer 6

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

Не уверен, считается ли этот цикл скрытым, но если он законный, то это идиоматическое решение проблемы. В противном случае вы можете сделать это.

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

Конечно, это фактически то, на что в любом случае будет преобразован цикл, но в наши дни, безусловно, осуждают на написание такого кода.

Answer 7

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

Answer 8

К тому времени, когда я отвечу на это, у кого-то уже будет это, так что здесь это в любом случае, с благодарностью Калебу:

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

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

Answer 9

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

Вот разбивка того, что происходит в приведенном выше коде:

• Enumerable.Range возвращает указанный диапазон целых чисел в виде IEnumerator
• Enumerable.ToList преобразует IEnumerable в список
• Список .ForEach принимает функцию 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);
        }
    }
}

Имея указанное выше расширение IEnumerable, теперь во всех местах, где вам нужно применить действие к IEnumerable, вы можете просто вызвать ForEach с лямбда-выражением. Итак, теперь оригинальный пример выглядит так:

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

Единственная разница в том, что мы больше не вызываем ToList, и это приводит к постоянному (O (1)) использованию пространства ... что было бы весьма ощутимым преимуществом, если бы вы обрабатывали действительно большое количество элементов.

Answer 10

Только для уродливой буквальной интерпретации:

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

(вы можете смеяться сейчас или позже или нет)