Question

How to print the numbers 0 to 31 by changing 1 bit each time in Scala

Answer 1

/*
    Title: Gray‑Code Sequence (One‑Bit‑Change Order)

    This program prints the 5‑bit Gray‑code sequence from 0 to 31.
    Gray code guarantees that each successive value differs by exactly one bit.

    Gray code formula:
        gray(n) = n ^ (n >> 1)

    The program prints the Gray‑code values themselves in the natural
    one‑bit‑change order: 0, 1, 3, 2, 6, 7, 5, 4, ...
*/

object GrayCodeSequence1 {

  /* Convert an integer to a 5‑bit binary string */
  def toBits(value: Int): String =
    value.toBinaryString.reverse.padTo(5, '0').reverse

  /* Print the Gray‑code sequence in one‑bit‑change order */
  def printGraySequence(): Unit = {
    for (n <- 0 until 32) {
      val g = n ^ (n >> 1)   // Gray‑code transformation
      println(f"$g%2d  ->  ${toBits(g)}")
    }
  }

  def main(args: Array[String]): Unit = {
    printGraySequence()
  }
}


/*
run:

 0  ->  00000
 1  ->  00001
 3  ->  00011
 2  ->  00010
 6  ->  00110
 7  ->  00111
 5  ->  00101
 4  ->  00100
12  ->  01100
13  ->  01101
15  ->  01111
14  ->  01110
10  ->  01010
11  ->  01011
 9  ->  01001
 8  ->  01000
24  ->  11000
25  ->  11001
27  ->  11011
26  ->  11010
30  ->  11110
31  ->  11111
29  ->  11101
28  ->  11100
20  ->  10100
21  ->  10101
23  ->  10111
22  ->  10110
18  ->  10010
19  ->  10011
17  ->  10001
16  ->  10000

*/

 

70+ SQL courses for beginners and professionals

Answer 2

/*
    Title: Gray‑Code Table (Numbers 1..31 with Bit Patterns)

    This program generates 5‑bit Gray‑code values for numbers 0–31.
    Gray code ensures that each successive value differs by exactly one bit.

    The program prints numbers 1..31 in normal numeric order,
    while showing their corresponding Gray‑code bit patterns.
*/

object GrayCodeSequence2 {

  /* Convert an integer to a 5‑bit binary string */
  def toBits(value: Int): String =
    value.toBinaryString.reverse.padTo(5, '0').reverse

  /* Print the Gray‑code table in numeric order */
  def printGrayTable(gray: Array[Int]): Unit = {
    for (n <- 1 until gray.length) {
      println(f"$n%2d  ->  ${toBits(gray(n))}")
    }
  }

  def main(args: Array[String]): Unit = {

    // Generate Gray‑code values for 0..31
    val gray: Array[Int] = Array.tabulate(32)(n => n ^ (n >> 1))

    // Print numbers 1..31 with their Gray‑code bit patterns
    printGrayTable(gray)
  }
}


/*
run:

 1  ->  00001
 2  ->  00011
 3  ->  00010
 4  ->  00110
 5  ->  00111
 6  ->  00101
 7  ->  00100
 8  ->  01100
 9  ->  01101
10  ->  01111
11  ->  01110
12  ->  01010
13  ->  01011
14  ->  01001
15  ->  01000
16  ->  11000
17  ->  11001
18  ->  11011
19  ->  11010
20  ->  11110
21  ->  11111
22  ->  11101
23  ->  11100
24  ->  10100
25  ->  10101
26  ->  10111
27  ->  10110
28  ->  10010
29  ->  10011
30  ->  10001
31  ->  10000

*/

 

70+ SQL courses for beginners and professionals