100 times "hello world" without loop or recursive

[Ram Kumar Subramaniam]

I read this on the sun forums
It was really interesting.........First i had a real laugh with the answers........then i realized that it was not some silly question.......a real good one.......then i really started reading to get the answer........and then somewhere in the middle there was a fabulous answer.........the best...
Guys read it.........will send the link where the correct answer is later

[aadhi agathi]

I appreciate it Jim Yes it's not worth it
[ May 09, 2003: Message edited by: aadhi agathi ]

[Ram Kumar Subramaniam]

Oops that was fast. Did u pick it for that forum or was it a very simple question for you to answer ?

And sorry for posting a java related question in a non java topic. -- Didnt notice the description.

[Jim Yingst]

Oops, sorry aadhi - here's the post again (more or less):
The requirements here seem a bit silly, and I think that any solution is going to be ultimately calling a loop or recursion somewhere in an existing class. Heck, even println("Hello World") by itself invokes a couple loops as it executes. But here's my contribution for what I see as a reasonable minimum of looping:

    String s = "Hello World\n";
    s += s + s + s + s;
    s += s + s + s + s;
    s += s + s + s;
    System.out.println(s);

[ May 09, 2003: Message edited by: Jim Yingst ]

[Francis Siu]

Ram
Ar...
It is a real good and interesting question.
Let me see..........
First idea come through my mind is use inheritance because it can produce some recursion effect.
Second idea is that use threads to do it,when count to 100 times then end the process of threads.
Are both ideas wrong?
Jim ,your idea seems to work.

[Jim Yingst]

Did u pick it for that forum or was it a very simple question for you to answer
I thought of it myself, after reading a couple pages from the forum and seeing a bunch of solutions that called other code that did the looping for them. I posted my idea here, then realized there were still loops hidden away inside so I deleted it, then said to heck with it and reposted. :roll: Then I read some more in the forum and found one guy who did something similar to my solution, using StringBuffer - but my code is much shorter looking.

[Ram Kumar Subramaniam]

That was great Jim. Well that answer didnt strike me at all.
siu, that was the answer.....posted earlier
But aadhi, did u get the the answer once u read the question. Didnt it, triger your thoughts ??

[SJ Adnams]

hmmn, i remember this being a similar puzzle in c/c++ but can't remember the solution
My guess would be to use constructor or destructors, maybe let the garbage collector do the iterating.
Are you sure Jim's answer is correct? doesn't seem very clever

[Ashok Mash]

We could use listner to the Timer and print 'Hello World' every second. Then we also need a counter to kill it clean once it prints this 100 times.

[John Smith]

Here is my favorite solution from the forum, with the creative use of classloader:
public class MyCrappyStupidAssHelloProgram
{
public static int instance = 0;
MyCrappyStupidAssHelloProgram()
{
instance ++;
System.out.println("Hello World!");
if(instance == 100) System.exit(1);
new MyCrappyStupidAssHelloProgram();
}
public static void main(String args[])
{
new MyCrappyStupidAssHelloProgram();
}
}

[Francis Siu]

yes Jim answer is correct
String s = "Hello World\n";
s += s + s + s + s;
//s=s+s+s+s+s
//s=5
s += s + s + s + s;
//s=5+5+5+5+5
//s=s+s+s+s+s
//s=25
s += s + s + s;
//s=s+s+s+s
//s=25+25+25+25
//s=100
System.out.println(s);

[ May 09, 2003: Message edited by: siu chung man ]

[SJ Adnams]

yes i know it's "correct", but it isn't "clever".

[Cindy Glass]

Well I think that it is. Anything that works that I did not come up with, somehow seems clever to me .
Brilliant Jim .

[SJ Adnams]

hmmn, the c++ solution can use a constructor to print, and "new" performs instantiation, so:
foo [] a = new foo[100];
will instantiate in c++ (i think). but this is not true in java. to get this method working in java would require using some nifty class that took an class and instantiated it. I've taken a look at the Arrays class but there is nothing nifty
the other construction method,
foo [] a = {new foo(), new foo(),...};
isn't much good to us either
I'll ponder over it down the pub

[Jim Yingst]

yes i know it's "correct", but it isn't "clever".
Well I'm happy enough with it for the problem as stated. But it's true that it wouldn't scale very well if we were asked to write something 421781 times rather than 100 - it would quickly lose the semblance of simplicity it has now. So I can agree that by some standards it lacks elegance.
Any solution using Timer will use loops built into the Timer code, IMO. But if we ignore this:

import java.util.*;
public class TimerUser
{
  public static void main(String[] args)
  {
    new Timer().schedule(
        new TimerTask()
            {
              int count;
              public void run() 
              {
                System.out.println("Hello World" + count);
                if (++count >= 100)
                  System.exit(0);
              }
            },
         new Date(), 1);
  }
}

I don't really like the MyCrappyStupidAssHelloProgram solution - isn't it just recursively calling the constructor from within the constructor? And what's the class loader got to do with it? You can insert a
new Throwable().printStackTrace();
next to the "Hello World" and see an ever-lengthening stack trace that looks pretty recursive to me.
Here's another solution which I like better: my interpretation of what siu said about using threads. To me it still feels somewhat recursive, but at least the method call stack isn't getting longer and longer.

public class ThreadSpawner extends Thread
{
  static volatile int count;
  public void run()
  {
    System.out.println("Hello World");
    if (++count < 100)
      new ThreadSpawner().start();
  }
  public static void main(String[] args)
  {
    new ThreadSpawner().start();
  }
}

[ May 09, 2003: Message edited by: Jim Yingst ]

[Manish Hatwalne]

Originally posted by Simon Lee:
hmmn, i remember this being a similar puzzle in c/c++ but can't remember the solution

C++ one is easier -
Just let the constructor of the class output the string, and create an array of 100 objects such as -
myObjects[100]; and it's done!
Another solution is by using Templates, which I don't remember.
- Manish

[Sameer Jamal]

Another solution in C++ or VB is use of goto statement
printhelloworld:
i=1;
if (i<= 100){<br /> cout>>("Hello World");
i=i+1;
goto printhelloworld
}

[Ravi Anamalay]

Does this count ? I've tried to do without a print function - although I'm sure its embedded somewhere. Its compiled with the " -source 1.4" option to enable assertions and run with "java -ea <program>".
class AHundred {
public static void main (String args[]) throws Exception {
String S="Hello World\n";

S = S+S+S+S+S+S+S+S+S+S;
S = S+S+S+S+S+S+S+S+S+S;
assert(false):S;
}
}

[Mark Spritzler]

Here's what my solution would have been. Taken from the third post in that thread.
"

 public class SurelyThisIsATroll {
    public static void main(String[] args) {
System.out.println("100 times �hello world�");
    }
} 

"
Mark
[ May 10, 2003: Message edited by: Mark Spritzler ]

[Mark Spritzler]

No on serious note this code to me is not recursive and very clever

 
public class foo{  
int i = 0;  
public void bar()  {      
System.out.println("Hello World");
if(++i < 100)baz();
}  
public void baz()  {
System.out.println("Hello World");
if(++i < 100)bar();       
}
} 

Mark

[Mark Spritzler]

But this has to be the best solution. Again taken from that thread.

 
import java.util.Arrays;
public class Test{
public static void main(String[] args){
String[] hellos = new String[100];
Arrays.fill(hellos, 0, 100, "Hello World");
System.out.print(Arrays.asList(hellos));
}
} 

Mark

[Jim Yingst]

No on serious note this code to me is not recursive and very clever
Not recursive? Really? I would call it an example of 2-phase recursion. I mean really, there are lots of CS homework assignments that ask for a nonrecursive solution of some sort, and it would be trivial to transform any simple recursive solution to a two-phase (or more) recursive solution. How many CS professors are likely to accept this sort of solution as "non-recursive"?
The Arrays solution is fairly elegant-looking, but merely hides its loops in the Arrays class. Though that sort of problem is admittedly endemic to any solution that prints, unless it prints one char at a time. I figure it's best to ignore that particular issue, but avoid any other looping or recursion. YMMV of course...

[Jignesh Malavia]

Will this linked list do :-)?

class Node
{
   private Node next = getNewInstance();  //Kind of a singly-linked-list
   Node()                                 //Non-recursive Constructor
   {
      System.out.println("Hello World!");
   }
//static
   private static int i=0;                 //instance counter
   private static Node getNewInstance()    //A Factory like method
   {
      if (i++ < 100)   return new Node();
      return null;
   }
   public static void main(String[] args)
   {
      Node head = new Node();              //A list of 100 Nodes
   }
}

There are not direct or indirect recursive methods from a programmer's point of view. Neither does it use any looping in a System provided class like ArrayList. It relies on the fact that 'creation' of one object triggers 'creation' of another- a kind of chain reaction.
(Edited to remove extra tabs. How do I insert blank lines in the code?)
[ May 10, 2003: Message edited by: Jignesh Malavia ]

[Jim Yingst]

Well, that's an interesting idea. I think that fundamentally it's pretty much equivalent to the previous MyCrappyStupidAssHelloProgram solution, in which the constructor was recursively calling the constructor. If you insert
new Throwable().printStackTrace();
just before the "Hello World", you'll see a series of lengthy stack traces like this:

Hello World!
java.lang.Throwable
at Node.<init>(Test.java:10)
at Node.getNewInstance(Test.java:19)
at Node.<init>(Test.java:6)
at Node.getNewInstance(Test.java:19)
at Node.<init>(Test.java:6)
at Test.main(Test.java:34)
Hello World!
java.lang.Throwable
at Node.<init>(Test.java:10)
at Node.getNewInstance(Test.java:19)
at Node.<init>(Test.java:6)
at Test.main(Test.java:34)
Hello World!
java.lang.Throwable
at Node.<init>(Test.java:10)
at Test.main(Test.java:34)
Hello World!

This is the very end of the output; at the beginning the stack trace is 200 lines long before Hello World is printed (100 levels of 2-phase recursion). So the recursion is hidden even better here, but it's still present, IMO.

[Jignesh Malavia]

Oops! Well, okay :-) That proved recursive- getNewInstance() calling itself. I had to put that static method to control the number of Nodes at 100. But now I have removed the static method as well as the constructor.

class Node
{
   private static int i=0;
   private Node next = (i++<100)?new Node():null;
   {
      System.out.println("Hello World!"); //instance initializer
   }
   public static void main(String[] args)   
   {
      Node head = new Node();
   }
}

And the stack trace for each nth object looks like this:

java.lang.Throwable
        at Node.<init>(Node.java:9)
        at Node.<init>(Node.java:5)
        at Node.<init>(Node.java:5)

... n-1 times
at Node.main(Node.java:15)
Hello World!
...

Of course, the process of creating the objects is recursive from JRE's point of view that it creates the 'next' object before it completes the creation of 'this' object. And it is the compiler that inserts the instance initializers into the generated <init> method. So if you say <init> is calling itself and is recursive, then I give up :-)
But the program does not use any user-defined recursive methods (like getNewInstance() of previous example) and we cannot see any user-defined methods repeating itself in the stack trace. So does this pass as a solution without recursive methods?
[ May 11, 2003: Message edited by: Jignesh Malavia ]

[John Lee]

i see lots of great ideas here. but why not just simply:
println("hello world/n") ;
............
............
............
repeating 100 times.
please note, it is not as hard as appeared. after you type the first, use copy & paste for 7 times, you got what you want.

[Jim Yingst]

That possibility is ruled out in the very first post on the Sun forum thread (by the guy who asked the question).

[John Lee]

oic, thanks!

[Michael Morris]

Well, I had to waste a little time on this too. So here is my solution:

import java.lang.reflect.*;
public class FindTheLoopHelloWorld100 extends ClassLoader {
    public static Class hello;
    private static final byte[] bytes = {-54, -2, -70, -66, 0, 0,
                                          0, 48, 0, 28, 10, 0,
                                          6, 0, 14, 9, 0, 15,
                                          0, 16, 8, 0, 17, 10,
                                          0, 18, 0, 19, 7, 0,
                                          20, 7, 0, 21, 1, 0,
                                          6, 60, 105, 110, 105, 116,
                                          62, 1, 0, 3, 40, 41,
                                          86, 1, 0, 4, 67, 111,
                                          100, 101, 1, 0, 15, 76,
                                          105, 110, 101, 78, 117, 109,
                                          98, 101, 114, 84, 97, 98,
                                          108, 101, 1, 0, 4, 100,
                                          111, 73, 116, 1, 0, 10,
                                          83, 111, 117, 114, 99, 101,
                                          70, 105, 108, 101, 1, 0,
                                          18, 72, 101, 108, 108, 111,
                                          87, 111, 114, 108, 100, 49,
                                          48, 48, 46, 106, 97, 118,
                                          97, 12, 0, 7, 0, 8,
                                          7, 0, 22, 12, 0, 23,
                                          0, 24, 1, 0, 11, 72,
                                          101, 108, 108, 111, 32, 87,
                                          111, 114, 108, 100, 7, 0,
                                          25, 12, 0, 26, 0, 27,
                                          1, 0, 13, 72, 101, 108,
                                          108, 111, 87, 111, 114, 108,
                                          100, 49, 48, 48, 1, 0,
                                          16, 106, 97, 118, 97, 47,
                                          108, 97, 110, 103, 47, 79,
                                          98, 106, 101, 99, 116, 1,
                                          0, 16, 106, 97, 118, 97,
                                          47, 108, 97, 110, 103, 47,
                                          83, 121, 115, 116, 101, 109,
                                          1, 0, 3, 111, 117, 116,
                                          1, 0, 21, 76, 106, 97,
                                          118, 97, 47, 105, 111, 47,
                                          80, 114, 105, 110, 116, 83,
                                          116, 114, 101, 97, 109, 59,
                                          1, 0, 19, 106, 97, 118,
                                          97, 47, 105, 111, 47, 80,
                                          114, 105, 110, 116, 83, 116,
                                          114, 101, 97, 109, 1, 0,
                                          7, 112, 114, 105, 110, 116,
                                          108, 110, 1, 0, 21, 40,
                                          76, 106, 97, 118, 97, 47,
                                          108, 97, 110, 103, 47, 83,
                                          116, 114, 105, 110, 103, 59,
                                          41, 86, 0, 33, 0, 5,
                                          0, 6, 0, 0, 0, 0,
                                          0, 2, 0, 1, 0, 7,
                                          0, 8, 0, 1, 0, 9,
                                          0, 0, 0, 29, 0, 1,
                                          0, 1, 0, 0, 0, 5,
                                          42, -73, 0, 1, -79, 0,
                                          0, 0, 1, 0, 10, 0,
                                          0, 0, 6, 0, 1, 0,
                                          0, 0, 1, 0, 9, 0,
                                          11, 0, 8, 0, 1, 0,
                                          9, 0, 0, 0, 59, 0,
                                          2, 0, 1, 0, 0, 0,
                                          23, 3, 59, -89, 0, 14,
                                          -78, 0, 2, 18, 3, -74,
                                          0, 4, -124, 0, 1, 26,
                                          16, 100, -95, -1, -14, -79,
                                          0, 0, 0, 1, 0, 10,
                                          0, 0, 0, 18, 0, 4,
                                          0, 0, 0, 3, 0, 5,
                                          0, 4, 0, 13, 0, 3,
                                          0, 22, 0, 6, 0, 1,
                                          0, 12, 0, 0, 0, 2,
                                          0, 13,};
    public FindTheLoopHelloWorld100() {
        super();
        hello = defineClass("HelloWorld100", bytes, 0, bytes.length);
    }

    public static void main(String[] args) throws Exception {
        new FindTheLoopHelloWorld100();
        Method doIt = hello.getDeclaredMethod("doIt", null);
        doIt.invoke(null, null);
    }
}

[boyet silverio]

C'mon guys! This isn't drivel!!

[Michael Morris]

C'mon guys! This isn't drivel!!
Well it's damn sure meaningless and 1 out of 2 ain't bad.

[Jim Yingst]

import java.io.*;
import java.lang.reflect.*;
public class FoundTheLoopHelloWorld100 extends ClassLoader
{
    public static Class look;
    private static final byte[] bytes =
        {
          -54, -2, -70, -66, 0, 0, 0, 48, 0, 29, 10, 0, 5, 0, 15, 9, 0, 16, 0,
          17, 10, 0, 18, 0, 19, 7, 0, 20, 7, 0, 21, 1, 0, 6, 60, 105, 110, 105,
          116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100, 101, 1, 0, 15,
          76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101,
          1, 0, 4, 115, 104, 111, 119, 1, 0, 10, 69, 120, 99, 101, 112, 116,
          105, 111, 110, 115, 7, 0, 22, 1, 0, 10, 83, 111, 117, 114, 99, 101,
          70, 105, 108, 101, 1, 0, 18, 72, 101, 114, 101, 115, 89, 111, 117,
          114, 76, 111, 111, 112, 46, 106, 97, 118, 97, 12, 0, 6, 0, 7, 7, 0,
          23, 12, 0, 24, 0, 25, 7, 0, 26, 12, 0, 27, 0, 28, 1, 0, 13, 72, 101,
          114, 101, 115, 89, 111, 117, 114, 76, 111, 111, 112, 1, 0, 16, 106,
          97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 1,
          0, 19, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 69, 120, 99, 101,
          112, 116, 105, 111, 110, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110,
          103, 47, 83, 121, 115, 116, 101, 109, 1, 0, 3, 111, 117, 116, 1, 0, 21,
          76, 106, 97, 118, 97, 47, 105, 111, 47, 80, 114, 105, 110, 116, 83,
          116, 114, 101, 97, 109, 59, 1, 0, 19, 106, 97, 118, 97, 47, 105, 111,
          47, 80, 114, 105, 110, 116, 83, 116, 114, 101, 97, 109, 1, 0, 5, 119,
          114, 105, 116, 101, 1, 0, 5, 40, 91, 66, 41, 86, 0, 33, 0, 4, 0, 5, 0,
          0, 0, 0, 0, 2, 0, 1, 0, 6, 0, 7, 0, 1, 0, 8, 0, 0, 0, 29, 0, 1, 0, 1,
          0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0, 1, 0, 9, 0, 0, 0, 6, 0, 1, 0,
          0, 0, 1, 0, 9, 0, 10, 0, 7, 0, 2, 0, 8, 0, 0, 5, 4, 0, 4, 0, 1, 0, 0,
          4, -28, 17, 0, -60, -68, 8, 89, 3, 16, 105, 84, 89, 4, 16, 109, 84, 89,
          5, 16, 112, 84, 89, 6, 16, 111, 84, 89, 7, 16, 114, 84, 89, 8, 16, 116,
          84, 89, 16, 6, 16, 32, 84, 89, 16, 7, 16, 106, 84, 89, 16, 8, 16, 97,
          84, 89, 16, 9, 16, 118, 84, 89, 16, 10, 16, 97, 84, 89, 16, 11, 16, 46,
          84, 89, 16, 12, 16, 105, 84, 89, 16, 13, 16, 111, 84, 89, 16, 14, 16,
          46, 84, 89, 16, 15, 16, 80, 84, 89, 16, 16, 16, 114, 84, 89, 16, 17,
          16, 105, 84, 89, 16, 18, 16, 110, 84, 89, 16, 19, 16, 116, 84, 89, 16,
          20, 16, 83, 84, 89, 16, 21, 16, 116, 84, 89, 16, 22, 16, 114, 84, 89,
          16, 23, 16, 101, 84, 89, 16, 24, 16, 97, 84, 89, 16, 25, 16, 109, 84,
          89, 16, 26, 16, 59, 84, 89, 16, 27, 16, 13, 84, 89, 16, 28, 16, 10, 84,
          89, 16, 29, 16, 13, 84, 89, 16, 30, 16, 10, 84, 89, 16, 31, 16, 112, 84,
          89, 16, 32, 16, 117, 84, 89, 16, 33, 16, 98, 84, 89, 16, 34, 16, 108,
          84, 89, 16, 35, 16, 105, 84, 89, 16, 36, 16, 99, 84, 89, 16, 37, 16,
          32, 84, 89, 16, 38, 16, 99, 84, 89, 16, 39, 16, 108, 84, 89, 16, 40,
          16, 97, 84, 89, 16, 41, 16, 115, 84, 89, 16, 42, 16, 115, 84, 89, 16,
          43, 16, 32, 84, 89, 16, 44, 16, 72, 84, 89, 16, 45, 16, 101, 84, 89,
          16, 46, 16, 108, 84, 89, 16, 47, 16, 108, 84, 89, 16, 48, 16, 111, 84,
          89, 16, 49, 16, 87, 84, 89, 16, 50, 16, 111, 84, 89, 16, 51, 16, 114,
          84, 89, 16, 52, 16, 108, 84, 89, 16, 53, 16, 100, 84, 89, 16, 54, 16,
          49, 84, 89, 16, 55, 16, 48, 84, 89, 16, 56, 16, 48, 84, 89, 16, 57, 16,
          13, 84, 89, 16, 58, 16, 10, 84, 89, 16, 59, 16, 123, 84, 89, 16, 60, 16,
          13, 84, 89, 16, 61, 16, 10, 84, 89, 16, 62, 16, 32, 84, 89, 16, 63, 16,
          32, 84, 89, 16, 64, 16, 32, 84, 89, 16, 65, 16, 32, 84, 89, 16, 66, 16,
          112, 84, 89, 16, 67, 16, 117, 84, 89, 16, 68, 16, 98, 84, 89, 16, 69,
          16, 108, 84, 89, 16, 70, 16, 105, 84, 89, 16, 71, 16, 99, 84, 89, 16,
          72, 16, 32, 84, 89, 16, 73, 16, 115, 84, 89, 16, 74, 16, 116, 84, 89,
          16, 75, 16, 97, 84, 89, 16, 76, 16, 116, 84, 89, 16, 77, 16, 105, 84,
          89, 16, 78, 16, 99, 84, 89, 16, 79, 16, 32, 84, 89, 16, 80, 16, 118,
          84, 89, 16, 81, 16, 111, 84, 89, 16, 82, 16, 105, 84, 89, 16, 83, 16,
          100, 84, 89, 16, 84, 16, 32, 84, 89, 16, 85, 16, 100, 84, 89, 16, 86,
          16, 111, 84, 89, 16, 87, 16, 73, 84, 89, 16, 88, 16, 116, 84, 89, 16,
          89, 16, 40, 84, 89, 16, 90, 16, 41, 84, 89, 16, 91, 16, 13, 84, 89,
          16, 92, 16, 10, 84, 89, 16, 93, 16, 32, 84, 89, 16, 94, 16, 32, 84,
          89, 16, 95, 16, 32, 84, 89, 16, 96, 16, 32, 84, 89, 16, 97, 16, 123,
          84, 89, 16, 98, 16, 13, 84, 89, 16, 99, 16, 10, 84, 89, 16, 100, 16,
          32, 84, 89, 16, 101, 16, 32, 84, 89, 16, 102, 16, 32, 84, 89, 16, 103,
          16, 32, 84, 89, 16, 104, 16, 32, 84, 89, 16, 105, 16, 32, 84, 89, 16,
          106, 16, 32, 84, 89, 16, 107, 16, 32, 84, 89, 16, 108, 16, 102, 84, 89,
          16, 109, 16, 111, 84, 89, 16, 110, 16, 114, 84, 89, 16, 111, 16, 40,
          84, 89, 16, 112, 16, 105, 84, 89, 16, 113, 16, 110, 84, 89, 16, 114,
          16, 116, 84, 89, 16, 115, 16, 32, 84, 89, 16, 116, 16, 105, 84, 89,
          16, 117, 16, 32, 84, 89, 16, 118, 16, 61, 84, 89, 16, 119, 16, 32, 84,
          89, 16, 120, 16, 48, 84, 89, 16, 121, 16, 59, 84, 89, 16, 122, 16, 32,
          84, 89, 16, 123, 16, 105, 84, 89, 16, 124, 16, 32, 84, 89, 16, 125, 16,
          60, 84, 89, 16, 126, 16, 32, 84, 89, 16, 127, 16, 49, 84, 89, 17, 0,
          -128, 16, 48, 84, 89, 17, 0, -127, 16, 48, 84, 89, 17, 0, -126, 16, 59,
          84, 89, 17, 0, -125, 16, 32, 84, 89, 17, 0, -124, 16, 105, 84, 89, 17,
          0, -123, 16, 43, 84, 89, 17, 0, -122, 16, 43, 84, 89, 17, 0, -121, 16,
          41, 84, 89, 17, 0, -120, 16, 13, 84, 89, 17, 0, -119, 16, 10, 84, 89,
          17, 0, -118, 16, 32, 84, 89, 17, 0, -117, 16, 32, 84, 89, 17, 0, -116,
          16, 32, 84, 89, 17, 0, -115, 16, 32, 84, 89, 17, 0, -114, 16, 32, 84,
          89, 17, 0, -113, 16, 32, 84, 89, 17, 0, -112, 16, 32, 84, 89, 17, 0,
          -111, 16, 32, 84, 89, 17, 0, -110, 16, 32, 84, 89, 17, 0, -109, 16, 32,
          84, 89, 17, 0, -108, 16, 32, 84, 89, 17, 0, -107, 16, 32, 84, 89, 17,
          0, -106, 16, 83, 84, 89, 17, 0, -105, 16, 121, 84, 89, 17, 0, -104, 16,
          115, 84, 89, 17, 0, -103, 16, 116, 84, 89, 17, 0, -102, 16, 101, 84,
          89, 17, 0, -101, 16, 109, 84, 89, 17, 0, -100, 16, 46, 84, 89, 17, 0,
          -99, 16, 111, 84, 89, 17, 0, -98, 16, 117, 84, 89, 17, 0, -97, 16, 116,
          84, 89, 17, 0, -96, 16, 46, 84, 89, 17, 0, -95, 16, 112, 84, 89, 17, 0,
          -94, 16, 114, 84, 89, 17, 0, -93, 16, 105, 84, 89, 17, 0, -92, 16, 110,
          84, 89, 17, 0, -91, 16, 116, 84, 89, 17, 0, -90, 16, 108, 84, 89, 17,
          0, -89, 16, 110, 84, 89, 17, 0, -88, 16, 40, 84, 89, 17, 0, -87, 16,
          34, 84, 89, 17, 0, -86, 16, 72, 84, 89, 17, 0, -85, 16, 101, 84, 89,
          17, 0, -84, 16, 108, 84, 89, 17, 0, -83, 16, 108, 84, 89, 17, 0, -82,
          16, 111, 84, 89, 17, 0, -81, 16, 32, 84, 89, 17, 0, -80, 16, 87, 84,
          89, 17, 0, -79, 16, 111, 84, 89, 17, 0, -78, 16, 114, 84, 89, 17, 0,
          -77, 16, 108, 84, 89, 17, 0, -76, 16, 100, 84, 89, 17, 0, -75, 16, 34,
          84, 89, 17, 0, -74, 16, 41, 84, 89, 17, 0, -73, 16, 59, 84, 89, 17, 0,
          -72, 16, 13, 84, 89, 17, 0, -71, 16, 10, 84, 89, 17, 0, -70, 16, 32,
          84, 89, 17, 0, -69, 16, 32, 84, 89, 17, 0, -68, 16, 32, 84, 89, 17, 0,
          -67, 16, 32, 84, 89, 17, 0, -66, 16, 125, 84, 89, 17, 0, -65, 16, 13,
          84, 89, 17, 0, -64, 16, 10, 84, 89, 17, 0, -63, 16, 125, 84, 89, 17, 0,
          -62, 16, 13, 84, 89, 17, 0, -61, 16, 10, 84, 75, -78, 0, 2, 42, -74, 0,
          3, -79, 0, 0, 0, 1, 0, 9, 0, 0, 0, 14, 0, 3, 0, 0, 0, 5, 4, -36, 0, 18,
          4, -29, 0, 19, 0, 11, 0, 0, 0, 4, 0, 1, 0, 12, 0, 1, 0, 13, 0, 0, 0, 2,
          0, 14
        };
    public FoundTheLoopHelloWorld100()
    {
        look = defineClass("HeresYourLoop", bytes, 0, bytes.length);
    }
    public static void main(String[] args) throws Exception
    {
        new FoundTheLoopHelloWorld100();
        Method doIt = look.getDeclaredMethod("show", null);
        doIt.invoke(null, null);
    }
}

[Michael Morris]

FoundTheLoopHelloWorld100

Smart ass!

[Ram Kumar Subramaniam]

FoundTheLoopHelloWorld100 .....

Oops i dont understand a thing.......From what i guess are u creating a class dynamically .....and those bytes is the actualy code or something ???

[SJ Adnams]

anyone looked at
java.swing.text.html.parseer.NPrintWriter
seems to do the job but of course has a loop inside.
I also thought about extending a streams class and setting the cache buffer somehow, override the flush() with a flush() followed by System.exit(). you would just then do a while(true) print("hello world");
still a loop.

[Francis Siu]

hi Michael and Jim
Could you describe what happened in the initialization of
private static final byte[] bytes = //...something ?
And what is the concept of the coding?
I really do not know what the coding mean.

thanks for your attention

[Anonymous]

The above solution again is not much elegant. I was about to post similar yesterday

[Michael Morris]

The above solution again is not much elegant.
Elegance is in the eye of the coder. But agreed, though sometimes clever trumps elegant.
And what is the concept of the coding? I really do not know what the coding mean.

Did you run the programs Siu? If not, try it. Just copy and paste them (do mine first and then Jim's most clever response) into your texteditor, then compile and run. Mine will print Hello World 100 times to stdout (duh!). The way this works is, I first created a class named HelloWorld100 with a single static method named doIt which used a simple for loop to print Hello World the 100 times. Next I wrote a simple routine to dump the declaration of byte[] bytes = { ... into a text file by reading the HelloWorld100.class which I later pasted into the above program. My class extends ClassLoader, so in the constructor I call defineClass() using the byte array and assign the returned Class object to the static hello member. Now all I have to do in main is call the constructor and use reflection to get to the static method doIt() and then call invoke() on the Method object and by some miracle Hello World is printed 100 times with no apparent loop or recursion.

[Jim Yingst]

For my part: I figured the static byte[] array was a class file, so I modified MM's program to write the array contents to a file named HelloWorld100.class. I used JAD to decompile this and get a possible version of HelloWorld100.java which would compile to the class file. A .class file doesn't have any info about things like MM's comments, level of indentation, etc. so the original HelloWorld.java could be cosmetically different, but is probably reasonably close to what I got. One complication was that JAD was last updated in 1999, and refuses to work with .class files whose version number exceeds 46 (meaning, no JDK 1.3 or 1.4). I got around this by manually changing 48 to 46 for the 8th byte in MM's array, effectively telling JAD to pretend the program was written for JDK 1.2. Evidently the format was close enough; JAD then decompiled without problems.
Once I had (a version of) HelloWorld100.java (which admittedly I also could have gotten just by guessing :roll: ) I wrote a program to print it to the screen (HeresYourLoop.java with static method show()), made a class file, and used the byte values of that class file to create FoundTheLoopHelloWorld100.java, using the same technique MM just described.
It's too bad JAD hasn't been maintained. Anyone know a good alternate out there that's kept pace with later class file versions?

[Michael Morris]

Next time I'll run it thru an obfuscater.
I figured you used JAD. Anyway it was a neat hack.