This commit is contained in:
Brian Buller 2016-09-08 06:39:08 -05:00
parent 1572f99a57
commit 148fad68a9
8 changed files with 232 additions and 23 deletions

View File

@ -1 +1 @@
bob gigasecond

View File

@ -0,0 +1,29 @@
using System;
using NUnit.Framework;
[TestFixture]
public class GigasecondTest
{
[Test]
public void First_date()
{
var date = Gigasecond.Date(new DateTime(2011, 4, 25, 0, 0, 0, DateTimeKind.Utc));
Assert.That(date, Is.EqualTo(new DateTime(2043, 1, 1, 1, 46, 40, DateTimeKind.Utc)));
}
[Test]
[Ignore("Remove to run test")]
public void Another_date()
{
var date = Gigasecond.Date(new DateTime(1977, 6, 13, 0, 0, 0, DateTimeKind.Utc));
Assert.That(date, Is.EqualTo(new DateTime(2009, 2, 19, 1, 46, 40, DateTimeKind.Utc)));
}
[Test]
[Ignore("Remove to run test")]
public void Yet_another_date()
{
var date = Gigasecond.Date(new DateTime(1959, 7, 19, 0, 0, 0, DateTimeKind.Utc));
Assert.That(date, Is.EqualTo(new DateTime(1991, 3, 27, 1, 46, 40, DateTimeKind.Utc)));
}
}

View File

@ -0,0 +1,19 @@
# Gigasecond
Write a program that calculates the moment when someone has lived for 10^9 seconds.
A gigasecond is 10^9 (1,000,000,000) seconds.
### Submitting Exercises
Note that, when trying to submit an exercise, make sure you're exercise file you're submitting is in the `exercism/csharp/<exerciseName>` directory.
For example, if you're submitting `bob.cs` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/csharp/bob/bob.cs`.
## Source
Chapter 9 in Chris Pine's online Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=09](http://pine.fm/LearnToProgram/?Chapter=09)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

View File

@ -1 +1 @@
matrix hexadecimal

26
go/hexadecimal/README.md Normal file
View File

@ -0,0 +1,26 @@
# Hexadecimal
Write a program that will convert a hexadecimal number, represented as a string (e.g. "10af8c"), to its decimal equivalent using first principles (i.e. no, you may not use built-in or external libraries to accomplish the conversion).
On the web we use hexadecimal to represent colors, e.g. green: 008000,
teal: 008080, navy: 000080).
The program should handle invalid hexadecimal strings.
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/examples/NumberBases.html](http://www.wolframalpha.com/examples/NumberBases.html)
## Submitting Incomplete Problems
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

View File

@ -0,0 +1,56 @@
package hexadecimal
import (
"errors"
"fmt"
"math/big"
"strings"
)
func ParseHex(in string) (int64, error) {
return convertNumStringBase(in, int64(16))
}
func HandleErrors(in []string) []string {
var ret []string
for i := range in {
_, err := convertNumStringBase(in[i], 16)
ret = append(ret, err.Error())
}
return ret
}
// convertNumStringBase takes a numeric string and the base of that string
// and returns an int64 of the decimal representation
func convertNumStringBase(in string, oldBase int64) (int64, error) {
if in == "" {
return 0, errors.New("syntax")
}
in = strings.ToLower(in)
base := big.NewInt(oldBase)
var sum big.Int
for i := range in {
var x *big.Int
if in[i] >= '0' && in[i] <= '9' {
x = big.NewInt(int64(in[i] - '0'))
} else if in[i] >= 'a' && in[i] <= 'z' {
x = big.NewInt(int64(in[i]-'a') + 10)
}
fmt.Println("Comparing Converted Value ", x, "<", oldBase)
if x.Int64() > oldBase {
return 0, errors.New("syntax")
}
pow := big.NewInt(int64(len(in) - i - 1))
var n big.Int
n.Exp(base, pow, nil)
n.Mul(x, &n)
sum.Add(&sum, &n)
if sum.Int64() < 0 {
return 0, errors.New("Integer Overflow")
}
}
return sum.Int64(), nil
}

View File

@ -0,0 +1,77 @@
// Your solution must include the following definitions:
//
// func ParseHex(string) (int64, error)
// func HandleErrors([]string) []string
//
// HandleErrors takes a list of inputs for ParseHex and returns a matching list
// of error cases. It must call ParseHex on each input, handle the error result,
// and put one of three strings, "none", "syntax", or "range" in the result list
// according to the error.
package hexadecimal
import (
"testing"
)
var testCases = []struct {
in string
out int64
errCase string
}{
{"1", 1, "none"},
{"10", 0x10, "none"},
{"2d", 0x2d, "none"},
{"012", 0x12, "none"},
{"cfcfcf", 0xcfcfcf, "none"},
{"CFCFCF", 0xcfcfcf, "none"},
{"", 0, "syntax"},
{"peanut", 0, "syntax"},
{"2cg134", 0, "syntax"},
{"8000000000000000", 0, "range"},
{"9223372036854775809", 0, "range"},
}
func TestParseHex(t *testing.T) {
for _, test := range testCases {
switch out, err := ParseHex(test.in); {
case err != nil:
if test.errCase == "none" {
t.Errorf("ParseHex(%q) returned error %q. Error not expected.",
test.in, err)
}
case test.errCase != "none":
t.Errorf("ParseHex(%q) = %d, %v. Expected error.",
test.in, out, err)
case out != test.out:
t.Errorf("ParseHex(%q) = %d. Expected %d.",
test.in, out, test.out)
}
}
}
func TestHandleErrors(t *testing.T) {
tests := make([]string, len(testCases))
for i, test := range testCases {
tests[i] = test.in
}
er := HandleErrors(tests)
if len(er) != len(tests) {
t.Fatalf("For %d tests, HandleErrors returned %d results, want %d",
len(tests), len(er), len(tests))
}
for i, e := range er {
if e != testCases[i].errCase {
t.Errorf("For ParseHex(%q), HandleErrors reports %q, want %q",
tests[i], e, testCases[i].errCase)
}
}
}
func BenchmarkParseHex(b *testing.B) {
for i := 0; i < b.N; i++ {
for _, test := range testCases {
ParseHex(test.in)
}
}
}

View File

@ -2,30 +2,32 @@ package trinary
import ( import (
"errors" "errors"
"fmt" "math/big"
"math"
) )
// ParseTrinary takes a trinary string and returns the // ParseTrinary takes a trinary string and returns the
// decimal value // decimal value
func ParseTrinary(in string) (int64, error) { func ParseTrinary(in string) (int64, error) {
fmt.Println("=== New Parse (" + in + ") ===") return convertNumStringBase(in, int64(3))
var ret int }
place := len(in)
// convertNumStringBase takes a numeric string and the base of that string
for i := range in { // and returns an int64 of the decimal representation
fmt.Print("Finding ", (place - i), " place value ", string(in[i])) func convertNumStringBase(in string, oldBase int64) (int64, error) {
switch in[i] { base := big.NewInt(oldBase)
case '0': var sum big.Int
case '1': for i := range in {
ret = ret + ((place - i) * 3) x := big.NewInt(int64(in[i] - '0'))
case '2': pow := big.NewInt(int64(len(in) - i - 1))
ret = ret + ((place - i) * int(math.Pow(3, 2)))
default: var n big.Int
return 0, errors.New("Invalid String") n.Exp(base, pow, nil)
} n.Mul(x, &n)
fmt.Println("==", ret)
place-- sum.Add(&sum, &n)
} if sum.Int64() < 0 {
return int64(ret), nil return 0, errors.New("Integer Overflow")
}
}
return sum.Int64(), nil
} }