Generating a sequence of numbers

Question

Hi there, I'm trying to generate a number sequence. The description is as follows:
a)1 is in the sequence
b) If number X is in the sequence then so are the numbers 3*X, 5*X, and 7*X.
c) No number appears more than once in the sequence, and
d) No other number is in the sequence.
Thus, first few numbers in the sequence are:
1,3,5,7,9,15,21,25,27,35,45,49,63,75,81,105...
I need to print out the first 1000 elements of this sequence which is fairly large.
How can i compute this sequence and print the first 1000 elements of this sequence? I think that we need 3 separate methods, 1 for 3*X, 5*X and 7*X. Can anyone out there help me with this?

Answer 1

The following code is in ML (because that's what I did this in for an exercise in my first year). datatype stream = Item of int * (unit->stream);
fun cons (x,xs) = Item (x,xs);
fun head (Item(i,xf))=i;
fun tail (Item(i,xf))=xf();
fun maps f xs = cons(f (head xs), fn()=> maps f (tail xs));
fun merge (xs,ys)=
    let val x = head (xs);
        val y = head (ys)
    in if x=y then cons(x, fn()=>merge((tail(xs)), (tail (ys))) )
       else if x<y then cons(x, fn()=>merge((tail(xs)), ys) )
            else cons(y, fn()=>merge(xs,(tail(ys))) ) end; (* y<x *)
fun merge3(xs,ys,zs) = merge(xs,merge(ys,zs));
fun threefiveseven()=
    cons(1, fn()=>
         merge3( maps (fn x=> 3*x) (threefiveseven()),
                 maps (fn x=> 5*x) (threefiveseven()),
                 maps (fn x=> 7*x) (threefiveseven()) )); Translating into Java elegantly isn't easy, because Java doesn't have function pointers. It took me quite a while, because it's difficult to avoid infinite recursion. (That's what the unit->stream and fn()=> is all about). Here you go: abstract class Function
    abstract int f(int i);
class Maps extends Stream
    Function f;
    Maps(Function f, Stream xs)
        this.head = f.f(xs.head());
        this.tail = xs;
        this.f = f;
    Stream tail()
        return new Maps(f, tail.tail());
class Merge extends Stream
    Stream xs;
    boolean tailxs;
    Stream ys;
    boolean tailys;
    Merge(Stream xs, Stream ys)
        int x = xs.head();
        int y = ys.head();
        this.xs = xs;
        this.ys = ys;
        if (x == y)
            head = x;
            tailxs = true;
            tailys = true;
        else if (x < y)
            head = x;
            tailxs = true;
            tailys = false;
        else
            head = y;
            tailxs = false;
            tailys = true;
    Stream tail()
        Stream left = (tailxs) ? xs.tail() : xs;
        Stream right = (tailys) ? ys.tail() : ys;
        return new Merge(left, right);
abstract class Stream
    int head;
    int head() { return head; }
    Stream tail;
    abstract Stream tail();
public class Test
    public static void main(String[] args)
        printFirst(new ThreeFiveSeven(), 10);
    static void printFirst(Stream stream, int n)
        while(n-- > 0)
            System.out.println(stream.head());
            stream = stream.tail();
class ThreeFiveSeven extends Stream
    ThreeFiveSeven()
        head = 1;
    Stream tail()
        Stream three = new Maps(new Times3(), new ThreeFiveSeven());
        Stream five = new Maps(new Times5(), new ThreeFiveSeven());
        Stream seven = new Maps(new Times7(), new ThreeFiveSeven());
        return new Merge(three, new Merge(five, seven));
class Times3 extends Function
    int f(int i) { return 3 * i; }
class Times5 extends Function
    int f(int i) { return 5 * i; }
class Times7 extends Function
    int f(int i) { return 7 * i; }
}