[Momerath]

A fairly simple challenge: Display "Hello, World" n times where 0 <= n <= 1000.
Rules: No loops (for, foreach, do/while,while are all forbidden, including their parallel equivalents), no LINQ. Each display must be on a separate line.

It's ok if your routine can handle values larger than 1000, just note any limitations.

Note: I have two solutions to this, just looking to see if there are any interesting methods I've missed

[tlhIn`toq]

Recurrsion isn't a loop, right?

Spoiler

using System;

namespace NoLoopHelloWorld
{
    class Program
    {

        static void Main(string[] args)
        {
            DoHelloWorld(0);
            Console.Write("Press [ENTER] to exit");
            Console.ReadLine();
        }

        private static void DoHelloWorld(int counter)
        {
            Console.WriteLine(string.Format("Hello World: {0}", ++counter));
            if (counter < 1000) DoHelloWorld(counter);
        }
    }
}

[Momerath]

Recursion is fine, and is one of the ways I'd come up with.

Another method:

Spoiler

using System;

namespace DreamInCode {
    public class HelloWorld {
        public static void Main() {
            int n = 1000;
            if ((n & 0x001) > 0) Print1();
            if ((n & 0x002) > 0) Print2();
            if ((n & 0x004) > 0) Print4();
            if ((n & 0x008) > 0) Print8();
            if ((n & 0x010) > 0) Print16();
            if ((n & 0x020) > 0) Print32();
            if ((n & 0x040) > 0) Print64();
            if ((n & 0x080) > 0) Print128();
            if ((n & 0x100) > 0) Print256();
            if ((n & 0x200) > 0) Print512();
        }

        public static void Print1()   { Console.WriteLine("Hello, World"); }
        public static void Print2()   { Print1();   Print1(); }
        public static void Print4()   { Print2();   Print2(); }
        public static void Print8()   { Print4();   Print4(); }
        public static void Print16()  { Print8();   Print8(); }
        public static void Print32()  { Print16();  Print16(); }
        public static void Print64()  { Print32();  Print32(); }
        public static void Print128() { Print64();  Print64(); }
        public static void Print256() { Print128(); Print128(); }
        public static void Print512() { Print256(); Print256(); }
    }
}

[wiero]

Spoiler

using System;
namespace ConsoleApplication19
{
	class Program
	{
		static void Main(string[] args)
		{
			var n = 1000;
			Console.WriteLine(new string('.', n).Replace(".", "Hello world!\n"));
			Console.ReadLine();
		}
	}
}

This post has been edited by wiero: 28 November 2012 - 12:42 AM

[rnty]

@Momerath:Why did you incorporate the if?

[Michael26]

If is a condition not a loop if i remember correctly

This post has been edited by Michael26: 28 November 2012 - 04:13 AM

[rnty]

I don't mean to challenge the author.I want to understand the logic.

This post has been edited by rnty: 28 November 2012 - 04:46 AM

[Momerath]

The if statements allow you to specify any number from 0 to 1023 and it will print that number of "Hello, World" statements.

And I'd not thought of wiero's method, even though I've used it before to answer someones question. I've also thought of a few more ways, but I'll let others post things before I add to this

[CasiOo]

First time I have got to create a struct /> !

Spoiler

            int n = 2;
            HelloWorld[] hellows = new HelloWorld[n];
            Console.WriteLine(string.Join<HelloWorld>("", hellows));

        public struct HelloWorld {
            public override string ToString() {
                return "Hello, World\n";
            }
        }

This post has been edited by CasiOo: 30 November 2012 - 12:58 PM

[AdamSpeight2008]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DIC_HelloWorld
{
  class Program
  {
    static void Main(string[] args)
    {
      int n=10;
      Console.WriteLine(Repeat("Hello World\n",n));
    }
    static string Repeat(string text, int n,string output="")
    {
      return (new Func<String>[]{()=> output,()=>Repeat(text,n-1,output + text)})[Math.Sign(n)]();
     }
  }
}

Would this be allowed.

  {
      int n=10;
      Enumerable.Repeat("Hello World!", n).ToList().ForEach(Console.WriteLine);
    }
 

  {
      int n=10;
      Console.WriteLine(String.Concat(Enumerable.Repeat("Hello World!\n", n)));
    }
 

This post has been edited by AdamSpeight2008: 30 November 2012 - 02:50 PM

[jon.kiparsky]

Momerath, on 28 November 2012 - 01:46 AM, said:

Recursion is fine, and is one of the ways I'd come up with.

Another method:

Spoiler

using System;

namespace DreamInCode {
    public class HelloWorld {
        public static void Main() {
            int n = 1000;
            if ((n & 0x001) > 0) Print1();
            if ((n & 0x002) > 0) Print2();
            if ((n & 0x004) > 0) Print4();
            if ((n & 0x008) > 0) Print8();
            if ((n & 0x010) > 0) Print16();
            if ((n & 0x020) > 0) Print32();
            if ((n & 0x040) > 0) Print64();
            if ((n & 0x080) > 0) Print128();
            if ((n & 0x100) > 0) Print256();
            if ((n & 0x200) > 0) Print512();
        }

        public static void Print1()   { Console.WriteLine("Hello, World"); }
        public static void Print2()   { Print1();   Print1(); }
        public static void Print4()   { Print2();   Print2(); }
        public static void Print8()   { Print4();   Print4(); }
        public static void Print16()  { Print8();   Print8(); }
        public static void Print32()  { Print16();  Print16(); }
        public static void Print64()  { Print32();  Print32(); }
        public static void Print128() { Print64();  Print64(); }
        public static void Print256() { Print128(); Print128(); }
        public static void Print512() { Print256(); Print256(); }
    }
}

This is a glorious kludge.

[Curtis Rutland]

I'm surprised this didn't come up yet:

Spoiler

static void Main(string[] args)
{
    var n = 1000;
    var i = 0;
start:
    Console.WriteLine("Hello, World -- {0}", i);
    if (++i < n) goto start;
    Console.ReadKey();
}

Simulates a loop, but doesn't use any actual loop constructs, so I think it fits the challenge.

[lucky3]

I'm surprised also:

Spoiler

Using timer (any other event based ideas?):

using System;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Timers.Timer myTimer = new System.Timers.Timer(5);
            myTimer.Elapsed += TimerTick;
            myTimer.Start();

            Console.ReadLine();
        }

         static int n = 0;
        static private void TimerTick(object sender, System.Timers.ElapsedEventArgs e)
        {
           n += 1;
            Console.WriteLine("Hello World {0}", n);

            if (n == 1000)
            {
                (sender as System.Timers.Timer).Stop();
            }
        }
    }
}

This post has been edited by lucky3: 06 December 2012 - 03:03 PM

[lucky3]

Would this (and similar) be considered like recursion?

Spoiler

using System;

namespace ConsoleApplication2
{
    class PingPongExample
    {
        static void Main(string[] args)
        {
            int n = 0;
            Ping(0);

            Console.ReadLine();
        }

        public static void Ping(int counter)
        {
            if (counter < 1000)
            {
                counter = Print(counter);
                Pong(counter);
            }
        }

        public static void Pong(int counter)
        {
            if (counter < 1000)
            {
                counter = Print(counter);
                Ping(counter);
            }
        }

        public static int Print(int counter)
        {
            counter += 1;
            Console.WriteLine("Hello, world " + counter);
            return counter;
        }
    }
}

[snypeNET]

My professors would probably go nuts if they saw this code because I was told to never use this method. But this was the first solution I could think of when I read the restrictions of the challenge.

Spoiler

using System;
using System.Collections.Generic;
using System.Text;

namespace loopLessHelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("How many times would you like to display \"Hello World\"? ");
            string helloCount = Console.ReadLine();
            try
            {
                int counter = int.Parse(helloCount);
                int outputCounter = 1;
                REPEAT:
                if (counter > 0 && counter <= 1000)
                {
                    Console.WriteLine(String.Format("{0}. Hello, World", outputCounter));
                    counter -= 1;
                    outputCounter += 1;
                    goto REPEAT;
                }
                Console.WriteLine("");
                Console.WriteLine("I have completed your request");
                Console.ReadLine();
            }
            catch (Exception)
            {
                Console.WriteLine("You have entered an incorrect value");
                Console.WriteLine("");
                Console.ReadLine();
            }
            
            
        }
    }
}

jon.kiparsky, on 30 November 2012 - 03:05 PM, said:

Momerath, on 28 November 2012 - 01:46 AM, said:

Recursion is fine, and is one of the ways I'd come up with.

Another method:

Spoiler

using System;

namespace DreamInCode {
    public class HelloWorld {
        public static void Main() {
            int n = 1000;
            if ((n & 0x001) > 0) Print1();
            if ((n & 0x002) > 0) Print2();
            if ((n & 0x004) > 0) Print4();
            if ((n & 0x008) > 0) Print8();
            if ((n & 0x010) > 0) Print16();
            if ((n & 0x020) > 0) Print32();
            if ((n & 0x040) > 0) Print64();
            if ((n & 0x080) > 0) Print128();
            if ((n & 0x100) > 0) Print256();
            if ((n & 0x200) > 0) Print512();
        }

        public static void Print1()   { Console.WriteLine("Hello, World"); }
        public static void Print2()   { Print1();   Print1(); }
        public static void Print4()   { Print2();   Print2(); }
        public static void Print8()   { Print4();   Print4(); }
        public static void Print16()  { Print8();   Print8(); }
        public static void Print32()  { Print16();  Print16(); }
        public static void Print64()  { Print32();  Print32(); }
        public static void Print128() { Print64();  Print64(); }
        public static void Print256() { Print128(); Print128(); }
        public static void Print512() { Print256(); Print256(); }
    }
}

This is a glorious kludge.

I agree.