From b6439da1a6a21789a4a25ed563803106ef1f1522 Mon Sep 17 00:00:00 2001
From: Hoanh An <hoanhan@bennington.edu>
Date: Wed, 2 Oct 2019 23:27:48 -0400
Subject: [PATCH] refactor radix sort

---
 other/bit_operations_test.go | 222 -----------------------------------
 other/radix_sort_test.go     |  40 ++++++-
 2 files changed, 36 insertions(+), 226 deletions(-)
 delete mode 100644 other/bit_operations_test.go

diff --git a/other/bit_operations_test.go b/other/bit_operations_test.go
deleted file mode 100644
index 49a8c91..0000000
--- a/other/bit_operations_test.go
+++ /dev/null
@@ -1,222 +0,0 @@
-// Problem:
-// Implement common Bit operations such as:
-// - Get Bit
-// - Set Bit
-// - Clear Bit (from most significant bit to i and from i to the least significant bit)
-// - Update Bit
-
-package other
-
-import (
-	"testing"
-
-	"github.com/hoanhan101/algo/common"
-)
-
-func TestGetBit(t *testing.T) {
-	tests := []struct {
-		in1      int
-		in2      int
-		expected uint
-	}{
-		{6, 0, 0},
-		{6, 1, 1},
-		{6, 2, 1},
-		{6, 3, 0},
-		{6, 4, 0},
-		{6, 5, 0},
-		{6, 6, 0},
-	}
-
-	for _, tt := range tests {
-		result := getBit(tt.in1, tt.in2)
-		common.Equal(t, tt.expected, result)
-	}
-}
-
-func TestSetBit(t *testing.T) {
-	tests := []struct {
-		in1      int
-		in2      int
-		expected int
-	}{
-		{6, 0, 7},
-		{6, 1, 6},
-		{6, 2, 6},
-		{6, 3, 14},
-		{6, 4, 22},
-		{6, 5, 38},
-		{6, 6, 70},
-	}
-
-	for _, tt := range tests {
-		result := setBit(tt.in1, tt.in2)
-		common.Equal(t, tt.expected, result)
-	}
-}
-
-func TestClearBit(t *testing.T) {
-	tests := []struct {
-		in1      int
-		in2      int
-		expected int
-	}{
-		{6, 0, 6},
-		{6, 1, 4},
-		{6, 2, 2},
-		{6, 3, 6},
-		{6, 4, 6},
-		{6, 5, 6},
-		{6, 6, 6},
-	}
-
-	for _, tt := range tests {
-		result := clearBit(tt.in1, tt.in2)
-		common.Equal(t, tt.expected, result)
-	}
-}
-
-func TestClearBitMSBToI(t *testing.T) {
-	tests := []struct {
-		in1      int
-		in2      int
-		expected int
-	}{
-		{6, 0, 0},
-		{6, 1, 0},
-		{6, 2, 2},
-		{6, 3, 6},
-		{6, 4, 6},
-		{6, 5, 6},
-		{6, 6, 6},
-	}
-
-	for _, tt := range tests {
-		result := clearBitMSBToI(tt.in1, tt.in2)
-		common.Equal(t, tt.expected, result)
-	}
-}
-
-func TestClearBitIToLSB(t *testing.T) {
-	tests := []struct {
-		in1      int
-		in2      int
-		expected int
-	}{
-		{6, 0, 6},
-		{6, 1, 4},
-		{6, 2, 0},
-		{6, 3, 0},
-		{6, 4, 0},
-		{6, 5, 0},
-		{6, 6, 0},
-	}
-
-	for _, tt := range tests {
-		result := clearBitIToLSB(tt.in1, tt.in2)
-		common.Equal(t, tt.expected, result)
-	}
-}
-
-func TestUpdateBit(t *testing.T) {
-	tests := []struct {
-		in1      int
-		in2      int
-		in3      bool
-		expected int
-	}{
-		{6, 0, true, 7},
-		{6, 1, true, 6},
-		{6, 2, true, 6},
-		{6, 3, true, 14},
-		{6, 4, true, 22},
-		{6, 5, true, 38},
-		{6, 6, true, 70},
-
-		{6, 0, false, 6},
-		{6, 1, false, 4},
-		{6, 2, false, 2},
-		{6, 3, false, 6},
-		{6, 4, false, 6},
-		{6, 5, false, 6},
-		{6, 6, false, 6},
-	}
-
-	for _, tt := range tests {
-		result := updateBit(tt.in1, tt.in2, tt.in3)
-		common.Equal(t, tt.expected, result)
-	}
-}
-
-// getBit returns the value of ith bit for a given number.
-func getBit(number, i int) uint {
-	// shift 1 over by i bits, creating a bitmask value.
-	mask := 1 << uint(i)
-
-	// perform an AND with number to clear all bits other than the one at bit i.
-	// if the value is not 0, bit 1 must have a 1.
-	if number&mask != 0 {
-		return 1
-	}
-
-	return 0
-}
-
-// setBit sets the value of ith bit for a given number.
-func setBit(number, i int) int {
-	// shift 1 over by i bits, creating a bitmask value.
-	mask := 1 << uint(i)
-
-	// perform an OR with number to change the number at bit i without
-	// affecting other values.,
-	return number | mask
-}
-
-// clearBit clears the value of ith bit for a given number.
-func clearBit(number, i int) int {
-	// shift 1 over by i bits, creating a bitmask value and negate it.
-	mask := ^(1 << uint(i))
-
-	// perform an AND with number to clear out all the bits 1.
-	return number & mask
-}
-
-// clearBitMSBToI clears all bits from the most significant bit to ith bit
-// for a given number.
-func clearBitMSBToI(number, i int) int {
-	// shift 1 over by i bits, creating a bitmask value and subtract 1 from it
-	// to get a sequence of 0s followed by i 1s.
-	mask := 1<<uint(i) - 1
-
-	// perform an AND with number to leave the last i bits.
-	return number & mask
-}
-
-// clearBitIToLSB clears all bits from ith bit to the least significant bit
-// for a given number.
-func clearBitIToLSB(number, i int) int {
-	// shift 1 over by i + 1 bits from a sequence of all 1s(which is -1) to get
-	// a sequence of 1s followed by i 0 bits.
-	mask := -1 << uint(i+1)
-
-	// perform an AND with number to cancel out the rest of 1 bits.
-	return number & mask
-}
-
-// updateBit updates the value of ith bit to either 1 or 0 for a given number.
-func updateBit(number, i int, isOne bool) int {
-	value := 0
-	if isOne {
-		value = 1
-	}
-
-	// shift 1 over by i bits, creating a bitmask value and negate it.
-	mask := ^(1 << uint(i))
-
-	// shift the value over by i bits to create a number with bit i equal to
-	// the value while other bits equal to 0.
-	n := value << uint(i)
-
-	// perform an OR with number to update the ith bit if the value is 1, or 0 otherwise.
-	return number&mask | n
-}
diff --git a/other/radix_sort_test.go b/other/radix_sort_test.go
index 6c6b814..2a2fb93 100644
--- a/other/radix_sort_test.go
+++ b/other/radix_sort_test.go
@@ -1,9 +1,6 @@
 // Problem:
 // Implement radix sort.
-//
-// Mechanic:
-// Sort the input numbers one digit at a time.
-//
+// // Mechanic: // Sort the input numbers one digit at a time.  //
 // Cost:
 // O(n) time and O(n) space.
 
@@ -39,6 +36,27 @@ func TestRadixSort(t *testing.T) {
 	}
 }
 
+func TestGetBit(t *testing.T) {
+	tests := []struct {
+		in1      int
+		in2      int
+		expected uint
+	}{
+		{6, 0, 0},
+		{6, 1, 1},
+		{6, 2, 1},
+		{6, 3, 0},
+		{6, 4, 0},
+		{6, 5, 0},
+		{6, 6, 0},
+	}
+
+	for _, tt := range tests {
+		result := getBit(tt.in1, tt.in2)
+		common.Equal(t, tt.expected, result)
+	}
+}
+
 func radixSort(in []int) []int {
 	out := []int{}
 	for i := 0; i < 64; i++ {
@@ -79,3 +97,17 @@ func sortingBit(in []int, bit int) []int {
 
 	return sorted
 }
+
+// getBit returns the value of ith bit for a given number.
+func getBit(number, i int) uint {
+	// shift 1 over by i bits, creating a bitmask value.
+	mask := 1 << uint(i)
+
+	// perform an AND with number to clear all bits other than the one at bit i.
+	// if the value is not 0, bit 1 must have a 1.
+	if number&mask != 0 {
+		return 1
+	}
+
+	return 0
+}