Mathematics 1201: Programming in C
	       Solutions to Reading and Homework Assignment #3
			     Prof. Wickerhauser

Chapter 3 Exercises:

Exercise 1, p.74
  Program:
    #include <stdio.h>
    main(void){
      int A, X, Y, Z;
      A = X = Y = Z = 1;
      A = ++X || ++Y && ++Z;
      printf("A=%d, X=%d, Y=%d, Z=%d\n", A, X, Y, Z);
      return 0;
    }
  Output:
    % a.out
    A=1, X=2, Y=1, Z=1

Exercise 9, p.75
  Program:
    #include <stdio.h>
    main(void){
      int x,y;

      /* Sums: */
      printf("x+y|");		/* Top line identifies table and x values */
      for(x=1; x<10; x++) printf("%4d", x);	/* 9 nums, 4 places/num. */
      printf("\n----------------------------------------\n"); /* 40 dashes */
      for(y=1; y<10; y++) {
	printf("%3d|", y);		/* Identify y in the leftmost col. */
	for(x=1; x<10; x++) printf("%4d", x+y); /* 9 sums/line, 4 places/sum */
	putchar('\n');		/* Go to the next line in the table */
      }
      putchar('\n');		/* Blank line before the next table */
      /* Products: */
      printf("x*y|");		/* Top line identifies table and x values */
      for(x=1; x<10; x++) printf("%4d", x);	/* 9 nums., 4 places/num. */
      printf("\n----------------------------------------\n"); /* 40 dashes */
      for(y=1; y<10; y++) {
	printf("%3d|", y);		/* Identify y in the leftmost col. */
	for(x=1; x<10; x++) printf("%4d", x*y); /* 9 prod./line, 4 places/p. */
	putchar('\n');		/* Go to the next line in the table */
      }
      return(0);
    }
  Output:
    % a.out
    x+y|   1   2   3   4   5   6   7   8   9
    ----------------------------------------
      1|   2   3   4   5   6   7   8   9  10
      2|   3   4   5   6   7   8   9  10  11
      3|   4   5   6   7   8   9  10  11  12
      4|   5   6   7   8   9  10  11  12  13
      5|   6   7   8   9  10  11  12  13  14
      6|   7   8   9  10  11  12  13  14  15
      7|   8   9  10  11  12  13  14  15  16
      8|   9  10  11  12  13  14  15  16  17
      9|  10  11  12  13  14  15  16  17  18

    x*y|   1   2   3   4   5   6   7   8   9
    ----------------------------------------
      1|   1   2   3   4   5   6   7   8   9
      2|   2   4   6   8  10  12  14  16  18
      3|   3   6   9  12  15  18  21  24  27
      4|   4   8  12  16  20  24  28  32  36
      5|   5  10  15  20  25  30  35  40  45
      6|   6  12  18  24  30  36  42  48  54
      7|   7  14  21  28  35  42  49  56  63
      8|   8  16  24  32  40  48  56  64  72
      9|   9  18  27  36  45  54  63  72  81


Exercise 12, p.75
  Program:
    #include <stdio.h>
    main(void){
      int a,b;
      for(b=1; b<1000; b++)
	for(a=1; a<b; a++)
	  if ( (a*a+b*b+1)%(a*b) == 0 )
	    printf("(A,B)=(%d,%d) works.\n", a, b);
      return(0);
    }
  Output:
    % a.out       
    (A,B)=(1,2) works.
    (A,B)=(2,5) works.
    (A,B)=(5,13) works.
    (A,B)=(13,34) works.
    (A,B)=(34,89) works.
    (A,B)=(89,233) works.
    (A,B)=(233,610) works.

  The values that appear, namely 1,2,5,13,34,89,233, and 610, are the odd
  entries f[1],f[3],f[5],... in the Fibonacci sequence 
    {f[n]: n=1,2,3,...} = {1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,...}
  which is generated by the rule f[n+1] = f[n] + f[n-1].


Exercise 18, p. 76:
  Program:
    #include <stdio.h>
    main(void){
      unsigned int N;
      int i, n;
      for( n=0; n<16; n++ ) {
	N = n;
	for( i=0 ; N &= N-1 ; i++ )
	  ;
	printf("initial N=%u ==> i=%d.\n", n, i);
      }
      return(0);
    }

  Output:
    % a.out
    initial N=0 ==> i=0.
    initial N=1 ==> i=0.
    initial N=2 ==> i=0.
    initial N=3 ==> i=1.
    initial N=4 ==> i=0.
    initial N=5 ==> i=1.
    initial N=6 ==> i=1.
    initial N=7 ==> i=2.
    initial N=8 ==> i=0.
    initial N=9 ==> i=1.
    initial N=10 ==> i=1.
    initial N=11 ==> i=2.
    initial N=12 ==> i=1.
    initial N=13 ==> i=2.
    initial N=14 ==> i=2.
    initial N=15 ==> i=3.
  The value `i' winds up with is one less than the number of 1-bits in the
  base-two representation of `N'.  This may be proved by observing that the
  bitwise conjunction N & N-1 yields N-(1<<k), where `k' is the index of the
  first 1-bit in N, starting from k=0 at the rightmost bit.  This is because
  we must borrow from that k'th bit to compute N-1, as seen in the following
  example:

	N       = 1101 1011 0000  (base 2)
	N-1     = 1101 1010 1111  (base 2)
 	------------------------------
        N & N-1 = 1101 1010 0000  (base 2)

  Thus each time we replace N with N & N-1, we remove one of N's 1-bits,
  starting from the right.  This is done before `i' is incremented, so `i'
  counts one fewer than the number of 1-bits in N.


Exercise 20, p. 76:
  Program:
    #include <stdio.h>
    #define ORDER(x,y,z,S) printf("Increasing order %lg,%lg,%lg (%s).\n",x,y,z,S)
    main(void){
      double a,b,c;
      printf("Enter A: ");  scanf("%lf", &a);
      printf("Enter B: ");  scanf("%lf", &b);
      printf("Enter C: ");  scanf("%lf", &c);
      if(a<b)
	if(b<c) ORDER(a,b,c,"A<B<C");
	else			/* a<b and c<=b: not ordered yet */
	  if(a<c) ORDER(a,c,b, "A<C<=B");
	  else ORDER(c,a,b, "C<=A<B");
      else				/* b<=a */
	if(a<c) ORDER(b,a,c, "B<=A<C");
	else			/* b<=a and c<=a: not ordered yet */
	  if(b<c) ORDER(b,c,a, "B<C<=A");
	  else ORDER(c,b,a, "C<=B<=A");
      return(0);
    }
  Output:
    % a.out       
    Enter A: 2
    Enter B: 3
    Enter C: -5
    Increasing order -5,2,3 (C<=A<B).