summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorDimitri Sokolyuk <demon@dim13.org>2016-08-28 01:56:09 +0200
committerDimitri Sokolyuk <demon@dim13.org>2016-08-28 01:56:09 +0200
commit8b2aa597999daf3efb5e842717fc2d373372ae4f (patch)
treed893416c2b2f0f0ed0fbe7a17e5beee096a220b0
parentd40949d4cfc17d784980f3bbc5da71b339539f48 (diff)
Solve binary
-rw-r--r--go/binary/README.md47
-rw-r--r--go/binary/binary.go17
-rw-r--r--go/binary/binary_test.go67
3 files changed, 131 insertions, 0 deletions
diff --git a/go/binary/README.md b/go/binary/README.md
new file mode 100644
index 0000000..7dd8010
--- /dev/null
+++ b/go/binary/README.md
@@ -0,0 +1,47 @@
+# Binary
+
+Write a program that will convert a binary number, represented as a string (e.g. '101010'), to its decimal equivalent using first principles
+
+Implement binary to decimal conversion. Given a binary input
+string, your program should produce a decimal output. The
+program should handle invalid inputs.
+
+## Note
+- Implement the conversion yourself.
+ Do not use something else to perform the conversion for you.
+
+## About Binary (Base-2)
+Decimal is a base-10 system.
+
+A number 23 in base 10 notation can be understood
+as a linear combination of powers of 10:
+
+- The rightmost digit gets multiplied by 10^0 = 1
+- The next number gets multiplied by 10^1 = 10
+- ...
+- The *n*th number gets multiplied by 10^*(n-1)*.
+- All these values are summed.
+
+So: `23 => 2*10^1 + 3*10^0 => 2*10 + 3*1 = 23 base 10`
+
+Binary is similar, but uses powers of 2 rather than powers of 10.
+
+So: `101 => 1*2^2 + 0*2^1 + 1*2^0 => 1*4 + 0*2 + 1*1 => 4 + 1 => 5 base 10`.
+
+To run the tests simply run the command `go test` in the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `-bench`
+flag:
+
+ go test -bench .
+
+For more detailed info about the Go track see the [help
+page](http://exercism.io/languages/go).
+
+## Source
+
+All of Computer Science [http://www.wolframalpha.com/input/?i=binary&a=*C.binary-_*MathWorld-](http://www.wolframalpha.com/input/?i=binary&a=*C.binary-_*MathWorld-)
+
+## Submitting Incomplete Problems
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+
diff --git a/go/binary/binary.go b/go/binary/binary.go
new file mode 100644
index 0000000..1a02992
--- /dev/null
+++ b/go/binary/binary.go
@@ -0,0 +1,17 @@
+package binary
+
+import "errors"
+
+func ParseBinary(s string) (int, error) {
+ var n int
+ for i, r := range s {
+ switch r {
+ case '0':
+ case '1':
+ n |= 1 << uint(len(s)-i-1)
+ default:
+ return 0, errors.New("invalid char")
+ }
+ }
+ return n, nil
+}
diff --git a/go/binary/binary_test.go b/go/binary/binary_test.go
new file mode 100644
index 0000000..cd5af58
--- /dev/null
+++ b/go/binary/binary_test.go
@@ -0,0 +1,67 @@
+package binary
+
+import (
+ "testing"
+)
+
+// You must implement the function,
+//
+// func ParseBinary(string) (int, error)
+//
+// It is standard for Go functions to return error values to report error conditions.
+// The test cases have some inputs that are invalid.
+// For invalid inputs, return an error that signals to the user why the error happened.
+// The test cases can only check that you return *some* error,
+// but it's still good practice to return useful errors.
+//
+// Also define a testVersion with a value that matches
+// the targetTestVersion here.
+
+const targetTestVersion = 1
+
+var testCases = []struct {
+ binary string
+ expected int
+ ok bool
+}{
+ {"1", 1, true},
+ {"10", 2, true},
+ {"11", 3, true},
+ {"100", 4, true},
+ {"1001", 9, true},
+ {"11010", 26, true},
+ {"10001101000", 1128, true},
+ {"0", 0, true},
+ {"foo101", 0, false},
+ {"101bar", 0, false},
+ {"101baz010", 0, false},
+ {"22", 0, false},
+}
+
+func TestParseBinary(t *testing.T) {
+ for _, tt := range testCases {
+ actual, err := ParseBinary(tt.binary)
+ if tt.ok {
+ if err != nil {
+ t.Fatalf("ParseBinary(%v) returned error %q. Error not expected.",
+ tt.binary, err)
+ }
+ if actual != tt.expected {
+ t.Fatalf("ParseBinary(%v): actual %d, expected %v",
+ tt.binary, actual, tt.expected)
+ }
+ } else if err == nil {
+ t.Fatalf("ParseBinary(%v) returned %d and no error. Expected an error.",
+ tt.binary, actual)
+ }
+ }
+}
+
+// Benchmark combined time for all tests
+func BenchmarkBinary(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ for _, tt := range testCases {
+ ParseBinary(tt.binary)
+ }
+ }
+}