trackler 2.0.6.36 → 2.0.6.37

data/tracks/go/exercises/forth/example.go

@@ -0,0 +1,238 @@
+// Package forth implements a tiny subset of the Forth language.
+package forth
+
+import (
+	"errors"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+type operatorFn func(stack *[]int) error
+
+type operatorId byte
+
+const (
+	addOp operatorId = iota
+	subOp
+	mulOp
+	divOp
+	dropOp
+	dupOp
+	swapOp
+	overOp
+	constOp
+	userDefOp
+	endDefOp
+)
+
+type operatorTyp struct {
+	fn operatorFn
+	id operatorId
+}
+
+func Forth(input []string) (result []int, err error) {
+	if len(input) == 0 {
+		return []int{}, nil
+	}
+
+	// Allocate an initially empty stack, with arbitrary starting capacity of 8.
+	stack := make([]int, 0, 8)
+	// Allocate a map for user defined words.
+	userDefs := make(map[string][]operatorTyp, 8)
+	for _, phrase := range input {
+		// Parse one phrase of input, building up an operator list.
+		opList, err := parse(phrase, userDefs)
+		if err != nil {
+			return nil, err
+		}
+		// Perform any operators from that phrase, updating stack.
+		for _, opr := range opList {
+			err = opr.fn(&stack)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return stack[:len(stack)], nil
+}
+
+// parse given phrase, returning an operator list, and updating
+// a userDefs map for any user definifion of words in phrase.
+func parse(phrase string, userDefs map[string][]operatorTyp) (oplist []operatorTyp, err error) {
+	words := strings.FieldsFunc(phrase,
+		func(r rune) bool {
+			return unicode.IsSpace(r) || unicode.IsControl(r)
+		})
+
+	// t is token index into words[]
+	for t := 0; t < len(words); t++ {
+		w := strings.ToUpper(words[t])
+		// Handle reference to user defined word.
+		if udef, ok := userDefs[w]; ok {
+			oplist = append(oplist, udef...)
+		} else if op, ok := builtinOps[w]; ok {
+			if op.id == userDefOp {
+				// Handle user defined word definition.
+				t++
+				if t >= len(words)-2 {
+					return nil, emptyUserDefErr
+				}
+				userword := strings.ToUpper(words[t])
+				if _, numerr := strconv.Atoi(userword); numerr == nil {
+					return nil, invalidUserDefErr
+				}
+				t++
+				var userops []operatorTyp
+				for t < len(words) {
+					oneOp, err := parse(words[t], userDefs)
+					if err != nil {
+						return nil, err
+					}
+					if oneOp[0].id == endDefOp {
+						break
+					}
+					userops = append(userops, oneOp...)
+					t++
+				}
+				if len(userops) == 0 {
+					return nil, emptyUserDefErr
+				} else {
+					userDefs[userword] = userops
+				}
+			} else {
+				// Normal builtin operator.
+				oplist = append(oplist, op)
+			}
+		} else {
+			// Handle constant literal.
+			var x int
+			x, err = strconv.Atoi(w)
+			if err != nil {
+				return nil, err
+			}
+			oplist = append(oplist,
+				operatorTyp{id: constOp,
+					fn: func(stack *[]int) error {
+						push(stack, x)
+						return nil
+					},
+				})
+		}
+	}
+	return oplist, nil
+}
+
+// builtinOps are the pre-defined operators to support.
+var builtinOps = map[string]operatorTyp{
+	"+":    {add, addOp},
+	"-":    {subtract, subOp},
+	"*":    {multiply, mulOp},
+	"/":    {divide, divOp},
+	"DUP":  {dup, dropOp},
+	"DROP": {drop, dupOp},
+	"SWAP": {swap, swapOp},
+	"OVER": {over, overOp},
+	":":    {nil, userDefOp},
+	";":    {nil, endDefOp},
+}
+
+func pop(stack *[]int) (v int, err error) {
+	slen := len(*stack)
+	if slen >= 1 {
+		v = (*stack)[slen-1]
+		*stack = (*stack)[:slen-1]
+		return v, nil
+	}
+	return 0, notEnoughOperands
+}
+
+func pop2(stack *[]int) (v1, v2 int, err error) {
+	v1, err = pop(stack)
+	if err != nil {
+		return 0, 0, err
+	}
+	v2, err = pop(stack)
+	return v1, v2, err
+}
+
+func push(stack *[]int, v int) {
+	*stack = append(*stack, v)
+}
+
+func binaryOp(stack *[]int, op func(a, b int) int) error {
+	v1, v2, err := pop2(stack)
+	if err != nil {
+		return err
+	}
+	push(stack, op(v2, v1))
+	return nil
+}
+
+func add(stack *[]int) (err error) {
+	return binaryOp(stack, func(a, b int) int { return a + b })
+}
+
+func subtract(stack *[]int) (err error) {
+	return binaryOp(stack, func(a, b int) int { return a - b })
+}
+
+func multiply(stack *[]int) error {
+	return binaryOp(stack, func(a, b int) int { return a * b })
+}
+
+func divide(stack *[]int) error {
+	v1, v2, err := pop2(stack)
+	if err != nil {
+		return err
+	}
+	if v1 == 0 {
+		return divideByZero
+	}
+	push(stack, v2/v1)
+	return nil
+}
+
+func dup(stack *[]int) error {
+	v1, err := pop(stack)
+	if err != nil {
+		return err
+	}
+	push(stack, v1)
+	push(stack, v1)
+	return nil
+}
+
+func drop(stack *[]int) error {
+	_, err := pop(stack)
+	return err
+}
+
+func over(stack *[]int) error {
+	v1, v2, err := pop2(stack)
+	if err != nil {
+		return err
+	}
+	push(stack, v2)
+	push(stack, v1)
+	push(stack, v2)
+	return nil
+}
+
+func swap(stack *[]int) error {
+	v1, v2, err := pop2(stack)
+	if err != nil {
+		return err
+	}
+	push(stack, v1)
+	push(stack, v2)
+	return nil
+}
+
+var notEnoughOperands error = errors.New("not enough operands")
+var divideByZero error = errors.New("attempt to divide by zero")
+var emptyUserDefErr error = errors.New("empty user definition")
+var invalidUserDefErr error = errors.New("invalid user def word")
+
+const testVersion = 1

data/tracks/go/exercises/forth/example_gen.go

@@ -0,0 +1,99 @@
+// +build ignore
+
+package main
+
+import (
+	"log"
+	"text/template"
+
+	"../../gen"
+)
+
+func main() {
+	t, err := template.New("").Parse(tmpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var j js
+	if err := gen.Gen("forth", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	ParsingAndNumbers  section `json:"parsing and numbers"`
+	Addition           section
+	Subtraction        section
+	Multiplication     section
+	Division           section
+	CombinedArithmetic section `json:"combined arithmetic"`
+	Dup                section
+	Drop               section
+	Swap               section
+	Over               section
+	UserDefinedWords   section `json:"user-defined words"`
+}
+
+// A grouped section of test cases.
+type section struct {
+	Cases []struct {
+		Description string
+		Input       []string
+		Expected    []int
+	}
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package forth
+
+// Source: {{.Ori}}
+{{if .Commit}}// Commit: {{.Commit}}
+{{end}}
+
+{{/* template for repeated caseSection */}}
+
+{{define "caseSection"}} = []testCase{
+{{range $y, $c := .}}{
+	{{printf "%q" $c.Description}},
+	{{printf "%#v" $c.Input}},
+	{{printf "%#v" $c.Expected}},
+},
+{{end}}}{{end}}
+
+var parsingGroup{{template "caseSection" .J.ParsingAndNumbers.Cases}}
+
+var additionGroup{{template "caseSection" .J.Addition.Cases}}
+
+var subtractionGroup{{template "caseSection" .J.Subtraction.Cases}}
+
+var multiplicationGroup{{template "caseSection" .J.Multiplication.Cases}}
+
+var divisionGroup{{template "caseSection" .J.Division.Cases}}
+
+var arithmeticGroup{{template "caseSection" .J.CombinedArithmetic.Cases}}
+
+var dupGroup{{template "caseSection" .J.Dup.Cases}}
+
+var dropGroup{{template "caseSection" .J.Drop.Cases}}
+
+var swapGroup{{template "caseSection" .J.Swap.Cases}}
+
+var overGroup{{template "caseSection" .J.Over.Cases}}
+
+var userdefinedGroup{{template "caseSection" .J.UserDefinedWords.Cases}}
+
+var testSections = []testcaseSection{
+	{"parsing", parsingGroup},
+	{"addition(+)", additionGroup},
+	{"subtraction(-)", subtractionGroup},
+	{"multiplication(*)", multiplicationGroup},
+	{"division(/)", divisionGroup},
+	{"arithmetic", arithmeticGroup},
+	{"dup", dupGroup},
+	{"drop", dropGroup},
+	{"swap", swapGroup},
+	{"over", overGroup},
+	{"user-defined", userdefinedGroup},
+}
+`

data/tracks/go/exercises/forth/forth_test.go

@@ -0,0 +1,64 @@
+package forth
+
+// API:
+// func Forth([]string) ([]int, error)
+//
+
+import (
+	"reflect"
+	"testing"
+)
+
+const targetTestVersion = 1
+
+type testCase struct {
+	description string
+	input       []string
+	expected    []int // nil slice indicates error expected.
+}
+
+type testcaseSection struct {
+	name  string
+	tests []testCase
+}
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
+func runTestCases(t *testing.T, sectionName string, testCases []testCase) {
+	for _, tc := range testCases {
+		description := sectionName + " - " + tc.description
+		if v, err := Forth(tc.input); err == nil {
+			var _ error = err
+			if tc.expected == nil {
+				t.Fatalf("%s\n\tForth(%#v) expected an error, got %v",
+					description, tc.input, v)
+			} else if !reflect.DeepEqual(v, tc.expected) {
+				t.Fatalf("%s\n\tForth(%#v) expected %v, got %v",
+					description, tc.input, tc.expected, v)
+			}
+		} else if tc.expected != nil {
+			t.Fatalf("%s\n\tForth(%#v) expected %v, got an error: %q",
+				description, tc.input, tc.expected, err)
+		}
+	}
+}
+
+func TestForth(t *testing.T) {
+	for _, testSection := range testSections {
+		runTestCases(t, testSection.name, testSection.tests)
+	}
+}
+
+func BenchmarkForth(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, testSection := range testSections {
+			for _, test := range testSection.tests {
+				Forth(test.input)
+			}
+		}
+	}
+}

data/tracks/java/exercises/phone-number/src/example/java/PhoneNumber.java

@@ -7,44 +7,38 @@ public class PhoneNumber {
     }
 
     private String extractDigits(String dirtyNumber) {
-        return dirtyNumber.replaceAll("[^\\d]", "");
+        StringBuilder stringBuilder = new StringBuilder();
+        for (char c : dirtyNumber.toCharArray()) {
+            if (c == ' ' || c == '.' || c == '(' || c == ')' || c == '-') {
+                // Remove spaces, dots, parentheses and hyphens
+                continue;
+            }
+            if (!Character.isDigit(c)) {
+                throw new IllegalArgumentException("Illegal character in phone number. "
+                        + "Only digits, spaces, parentheses, hyphens or dots accepted.");
+            }
+            stringBuilder.append(c);
+        }
+        return stringBuilder.toString();
     }
 
     private String normalize(String number) {
-        if(number.length() > 11 || number.length() < 10){
+        if (number.length() > 11 || number.length() < 10) {
             throw new IllegalArgumentException("Number must be 10 or 11 digits");
         }
 
-        if(number.length() == 11){
-            if(number.startsWith("1")){
+        if (number.length() == 11) {
+            if (number.startsWith("1")) {
                 number = number.substring(1, number.length());
-            }
-            else{
+            } else {
                 throw new IllegalArgumentException("Can only have 11 digits if number starts with '1'");
             }
-        } 
-        
+        }
+
         return number;
     }
 
     public String getNumber() {
         return number;
     }
-
-    public String getAreaCode() {
-        return number.substring(0, 3);
-    }
-
-    public String getExchangeCode() {
-        return number.substring(3, 6);
-    }
-
-    public String getSubscriberNumber() {
-        return number.substring(6, 10);
-    }
-
-    public String pretty() {
-        return "(" + getAreaCode() + ") " + getExchangeCode() + "-" + getSubscriberNumber();
-    }
-
 }