Display numbers from 1 to 100 without loops or conditions [closed]

Answer 1

Pseudo code. Uses an array to force an exception after 100 elements which is caught and does nothing.

function r(array a, int index){
    a[index] = a[index-1]+1
    print a[index]
    r(a, index+1)
}

try{
    array a;
    a.resize(101)
    r(a, 1)
}catch(OutOfBoundsException){
}

EDIT
Java code:

public void printTo100(){
    int[] array = new int[101];
    try{
        printToArrayLimit(array, 1);
    }catch(ArrayIndexOutOfBoundsException e){
    }
}
public void printToArrayLimit(int[] array, int index){
    array[index] = array[index-1]+1;
    System.out.println(array[index]);
    printToArrayLimit(array, index+1);
}

Answer 2

Ok, I'm late on this and an answer is already accepted, but I wonder why nobody has used a clean and simple counter yet?

public class Counter
{
    static Counter[] vtab = new Counter[]
    {
        new Counter(),
        new Counter() { public void print( int first, int last ) {} }
    };

    public void print( int first, int last )
    {
        vtab[ ( last - first - 1 ) >>> 31 ].print( first, last - 1 );
        System.out.println( last );
    }

    public static void main( String[] args )
    {
        vtab[ 0 ].print( 1, 100 );
    }
}

Thread safe, configurable, no exceptions, no dependance on API side effects, just plain OOP and some trivial math.

---

For those not familiar with binary operators here is how it works:

• The ( x >>> n ) expression moves all bits of the integer value x to the right by n places. Lower bits simply fall off the right side by this operation and new bits that come in from the left side are always 0.

• So the effect of ( x >>> 31 ) is to move the highest bit of x to the lowest place and to set all other bits of x to 0. The result is now always either 0 or 1 for all possible values of x.

• As the highest bit of an int is the sign bit which is 0 for positive values and 1 for negative values, the expression ( x >>> 31 ) evaluates to 0 for all positve values of x and to 1 for all negative values of x.

• Now if both first and last are positive numbers and if last is greater than first, the result of ( last - first - 1 ) will be >= 0 and if last == first it will be -1.

• So ( ( last - first - 1 ) >>> 31 ) evaluates to 0 if last is greater than first and becomes 1 if they are equal.

Now this value 0/1 is used to switch between the 2 implementations of print( int first, int last ) based on the comparision of first and last. At first the recursion takes place without printing anything. print( 1, 100 ) calls print( 1, 99 ) and so on... until last equals first which causes a switch to the other implementation of print which in turn does nothing at all. So now the stack unwinds again and the values are printed on the way down in ascending order and the invocation of vtab[ 0 ].print( 1, 100 ) finishes normally.

Answer 3

let Arrays do the job:

public static void main(String[] args) {
    Object[] numbers = new Object[100];
    Arrays.fill(numbers, new Object() {
        private int count = 0;
        @Override
        public String toString() {
            return Integer.toString(++count);
        }
    });
    System.out.println(Arrays.toString(numbers));
}

Answer 4

No conditions (no short-cut boolean operators, no ?-operator, no exceptions), no loops:

import java.util.Vector;

public class PrintOneToHundered {
  static int i;
  PrintOneToHundered() {}
  public String toString() { return ++i+""; }
  public static void main(String[] args) {
    Vector v1  =new Vector(); v1  .add(new PrintOneToHundered());
    Vector v2  =new Vector(); v2  .addAll(v1 ); v2  .addAll(v1 );
    Vector v4  =new Vector(); v4  .addAll(v2 ); v4  .addAll(v2 );
    Vector v8  =new Vector(); v8  .addAll(v4 ); v8  .addAll(v4 );
    Vector v16 =new Vector(); v16 .addAll(v8 ); v16 .addAll(v8 );
    Vector v32 =new Vector(); v32 .addAll(v16); v32 .addAll(v16);
    Vector v64 =new Vector(); v64 .addAll(v32); v64 .addAll(v32);
    Vector v100=new Vector(); v100.addAll(v64); v100.addAll(v32); v100.addAll(v4);
    System.out.println(v100);
  }
}

Explanation:

• define a class, whose toString-method returns consecutive ints at repeated calls
• create a vector with 100 elements, that are instances of the class
• print the vector (toString-method of a Vector returns a string of the toString-values of all its elements)

Answer 5

Here is one using a thread (I inflated the sleep time to account for fluctuations in system speed). I couldn't think of a way to get rid of the try / catch:

public class Counter extends Thread{

    private int cnt;

    public Counter(){
        this.cnt = 0;
    }

    private void increment(){
        System.out.println(cnt++);
        try{
            Thread.sleep(1000);
        }catch(Exception e){}
        increment();
    }

    public void run(){
        increment();
    }

    public static void main(String[] args) throws Exception{
        Counter cntr = new Counter();
        cntr.start();
        cntr.join(100000);
        cntr.interrupt();
        System.exit(0);
    }

}

Answer 6

Yes, it's possible, but it's terrible. There's any number of ways that will use either recursion or nested type creation, with exception handling for flow control. This has no real-world application IMO and should be avoided in real code at all costs.

Here's an example that uses recursive type instantiation with exception handling to control termination. It print the number is descending order, but that would be trivial to change to ascending, by just subtracting 99 (or whatever constant) from the value being printed.

class PrintVal
{
  // called with a list containing as many items as you want, less one...
  public PrintVal( List<int> items )
  {
      System.out.println(items.size()+1);  // print the size of the list
      try { 
        items.remove( items.size()-1 );  // will throw when items is empty
        new PrintVal( items );
      }
      catch( Exception ) { /* swallow and terminate */ }
  }
}

// setup and invocation that performs the output
ArrayList<int> strList = new ArrayList<int>( new int[99] );
PrintVal instance = new PrintVal( strList );  // all output happens here