trackler 2.0.8.34 → 2.0.8.35

data/tracks/go/exercises/change/change_test.go

@@ -0,0 +1,48 @@
+package change
+
+import (
+	"reflect"
+	"testing"
+)
+
+const targetTestVersion = 1
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
+func TestChange(t *testing.T) {
+	for _, tc := range testCases {
+		actual, err := Change(tc.coins, tc.target)
+		if tc.valid {
+			if err != nil {
+				t.Fatalf("%s : Change(%v, %d): expected %v, got error %s",
+					tc.description, tc.coins, tc.target, tc.expectedChange, err)
+			} else {
+				if !reflect.DeepEqual(actual, tc.expectedChange) {
+					t.Fatalf("%s : Change(%v, %d): expected %v, actual %v",
+						tc.description, tc.coins, tc.target, tc.expectedChange, actual)
+				} else {
+					t.Logf("PASS: %s", tc.description)
+				}
+			}
+		} else {
+			if err == nil {
+				t.Fatalf("%s : Change(%v, %d): expected error, got %v",
+					tc.description, tc.coins, tc.target, actual)
+			} else {
+				t.Logf("PASS: %s", tc.description)
+			}
+		}
+	}
+}
+
+func BenchmarkChange(b *testing.B) {
+	for _, tc := range testCases {
+		for i := 0; i < b.N; i++ {
+			Change(tc.coins, tc.target)
+		}
+	}
+}

data/tracks/go/exercises/change/example.go

@@ -0,0 +1,153 @@
+// Package change demonstrates making change with fewest number of coins.
+package change
+
+import (
+	"errors"
+	"sort"
+)
+
+const testVersion = 1
+
+var (
+	ErrNoSolutionFound = errors.New("No solution")
+	ErrNegativeTarget  = errors.New("Negative Target")
+)
+
+// Change returns a list of coins in increasing value order to make
+// change for target amount from the coins given; an infinite supply of coins is assumed.
+func Change(coins []int, target int) ([]int, error) {
+	var solution []int
+	if target == 0 {
+		// No change needed for 0.
+		return []int{}, nil
+	}
+	if target < 0 {
+		// No change possible for negative.
+		return nil, ErrNegativeTarget
+	}
+	findSolution(coins, target, &solution)
+	if len(solution) == 0 {
+		// No solution possible with coins given.
+		return nil, ErrNoSolutionFound
+	}
+	return solution, nil
+}
+
+// findSolution attempts to find a change solution for target amount
+// from the coins given.
+func findSolution(coins []int, target int, s *[]int) {
+	// Find the coins to consider, less than the target change amount.
+	last := len(coins) - 1
+	for ; last >= 0; last-- {
+		if coins[last] == target {
+			// Perfect single coin solution, so done!
+			*s = []int{target}
+			return
+		}
+		if coins[last] > target {
+			// Cannot use this too large coin.
+			continue
+		}
+		// Now, 0 .. last are the coins to consider.
+		break
+	}
+	if last < 0 {
+		// All coins larger than target.
+		return
+	}
+
+	bestsize := target + 1 // an initial "worst" bestsize
+	findUsingPartialSolution(nil, coins[0:last+1], target, s, &bestsize)
+}
+
+// updateSolution updates solution with newsolution if no prior solution
+// or when length of newsolution is better.
+func updateSolution(newsolution []int, solution *[]int, bestsize *int) {
+	if len(*solution) == 0 || len(newsolution) < len(*solution) {
+		*bestsize = len(newsolution)
+		*solution = make([]int, len(newsolution))
+		copy(*solution, newsolution)
+		sort.Ints(*solution)
+	}
+}
+
+// findUsingPartialSolution takes a partial solution, and coin list c looking to meet target
+// while updating solution s to include partial plus the coins meeting target.
+func findUsingPartialSolution(partial []int, c []int, target int, s *[]int, bestsize *int) {
+	// We want to consider coins in c in largest to smallest order.
+	sort.Sort(sort.Reverse(sort.IntSlice(c)))
+
+	for e, coin := range c {
+		// Find n, which is highest number of coin that could be used in change.
+		n := target / coin
+
+		// Try n, n-1 ... 1
+		for k := n; k >= 1; k-- {
+			if (k * coin) == target {
+				// k coin(s) completes a solution.
+				if (len(partial) + k) < *bestsize {
+					list := append(partial, nCoins(k, coin)...)
+					updateSolution(list, s, bestsize)
+				}
+				// No need to consider smaller k for coin, so exit this loop.
+				break
+			}
+			if len(c) > 1 {
+				// k coin(s) might be potential partial solution.
+				newtarget := target - (k * coin)
+				// Use a heuristic estimate of whether a partial solution
+				// might be worth it: if the larget coin in c not yet used
+				// in an already found solution allows the new solution
+				// to be smaller, then it would be worth pursuing.
+
+				// Find the largest coin in c not yet used in *s solution
+				// omitting coin, since it is used in this partial solution.
+				largest := largestNotUsed(c, *s, coin)
+				// It will take at least the partial, plus k coins plus 1 more.
+				if (len(partial) + k + 1) < *bestsize {
+					// Calculate the minimum potential size of a solution
+					// which doesn't include this coin.
+					potentialSize := len(partial) + k + (newtarget / largest)
+					if (newtarget % largest) != 0 {
+						potentialSize++
+					}
+					if potentialSize < *bestsize {
+						// Put k instances of coin in a new partial solution.
+						newPartial := append(partial, nCoins(k, coin)...)
+						d := append(append([]int{}, c[:e]...), c[e+1:]...)
+						// Now look for solution meeting *new* target.
+						findUsingPartialSolution(newPartial, d, newtarget, s, bestsize)
+					}
+				}
+			}
+		}
+	}
+}
+
+// Find the largest coin in coins not yet used in solution, not including coin 'omit'.
+// The coins are in largest to smallest order.
+func largestNotUsed(coins []int, solution []int, omit int) int {
+coinLoop:
+	for _, coin := range coins {
+		if coin == omit {
+			continue
+		}
+		for _, used := range solution {
+			if coin == used {
+				continue coinLoop
+			}
+		}
+		return coin
+	}
+	// Should not get here. But unity is safe return value.
+	return 1
+}
+
+// nCoins returns a list(slice) of length n of a specific coin value.
+func nCoins(n int, coin int) []int {
+	coins := make([]int, n)
+	for i := 0; i < n; i++ {
+		coins[i] = coin
+	}
+	return coins
+}

data/tracks/go/exercises/change/example_gen.go

@@ -0,0 +1,96 @@
+// +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("change", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Exercise string
+	Version  string
+	Comments []string
+	Cases    []OneCase
+}
+
+// template applied to above data structure generates the Go test cases
+
+type OneCase struct {
+	Description string
+	Property    string
+	Coins       []int
+	Target      int
+	Expected    interface{}
+}
+
+func (c OneCase) Valid() bool {
+	valid, _ := determineExpected(c.Expected)
+	return valid
+}
+
+func (c OneCase) IntSlice() []int {
+	_, list := determineExpected(c.Expected)
+	return list
+}
+
+// determineExpected examines an .Expected interface{} object and determines
+// whether an error is indicated by an int value (actually -1) in the JSON,
+// or whether .Expected is a slice of integer coins.
+func determineExpected(expected interface{}) (valid bool, list []int) {
+	_, ok := expected.(int)
+	if ok {
+		return false, nil
+	}
+	ilist, ok := expected.([]interface{})
+	if !ok {
+		return false, nil
+	}
+	list = make([]int, 0)
+	for _, iv := range ilist {
+		// The literals from the JSON are unmarshalled to float64 values,
+		// which are converted to int for the template output.
+		v, isFloat64 := iv.(float64)
+		if isFloat64 {
+			list = append(list, int(v))
+		}
+	}
+	return true, list
+}
+
+var tmpl = `package change
+
+// Source: {{.Ori}}
+{{if .Commit}}// Commit: {{.Commit}}
+{{end}}
+
+var testCases = []struct {
+	description    string
+	coins          []int
+	target         int
+	valid          bool     // true => no error, false => error expected
+	expectedChange []int    // when .valid == true, the expected change coins
+}{
+{{range .J.Cases}}{
+	{{printf "%q"  .Description}},
+	{{printf "%#v" .Coins}},
+	{{printf "%d"  .Target}},
+	{{printf "%v"  .Valid}},
+	{{printf "%#v" .IntSlice}},
+},
+{{end}}}
+`

data/tracks/java/exercises/beer-song/src/example/java/BeerSong.java

@@ -1,8 +1,6 @@
 public class BeerSong {
-    public static String verse(int number)
-    {
-        switch (number)
-        {
+    public String verse(int number) {
+        switch (number) {
             case 0:
                 return "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n\n";
             case 1:
@@ -14,8 +12,7 @@ public class BeerSong {
         }
     }
 
-    public static String sing(int start, int stop)
-    {
+    public String sing(int start, int stop) {
         StringBuilder songOutput = new StringBuilder();
 
         for (int i=start; i>=stop; i--) {
@@ -25,7 +22,7 @@ public class BeerSong {
         return songOutput.toString();
     }
 
-    public static String singSong() {
+    public String singSong() {
         return sing(99,0);
     }
 }

data/tracks/java/exercises/beer-song/src/test/java/BeerSongTest.java

@@ -1,15 +1,23 @@
 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Before;
 
 import static org.junit.Assert.assertEquals;
 
 public class BeerSongTest {
 
+    private BeerSong beerSong;
+
+    @Before
+    public void setup(){
+        beerSong = new BeerSong();
+    }
+
     @Test
     public void singFirstVerse() {
         assertEquals("99 bottles of beer on the wall, 99 bottles of beer.\n" +
                         "Take one down and pass it around, 98 bottles of beer on the wall.\n\n",
-                BeerSong.verse(99));
+                beerSong.verse(99));
     }
 
     @Ignore
@@ -17,7 +25,7 @@ public class BeerSongTest {
     public void singMiddleVerse() {
         assertEquals("44 bottles of beer on the wall, 44 bottles of beer.\n" +
                         "Take one down and pass it around, 43 bottles of beer on the wall.\n\n",
-                BeerSong.verse(44));
+                beerSong.verse(44));
     }
 
     @Ignore
@@ -25,7 +33,7 @@ public class BeerSongTest {
     public void singThirdToLastVerse() {
         assertEquals("2 bottles of beer on the wall, 2 bottles of beer.\n" +
                         "Take one down and pass it around, 1 bottle of beer on the wall.\n\n",
-                BeerSong.verse(2));
+                beerSong.verse(2));
     }
 
     @Ignore
@@ -33,7 +41,7 @@ public class BeerSongTest {
     public void singPenultimateVerse() {
         assertEquals("1 bottle of beer on the wall, 1 bottle of beer.\n" +
                         "Take it down and pass it around, no more bottles of beer on the wall.\n\n",
-                BeerSong.verse(1));
+                beerSong.verse(1));
     }
 
     @Ignore
@@ -41,7 +49,7 @@ public class BeerSongTest {
     public void singLastVerse() {
         assertEquals("No more bottles of beer on the wall, no more bottles of beer.\n" +
                         "Go to the store and buy some more, 99 bottles of beer on the wall.\n\n",
-                BeerSong.verse(0));
+                beerSong.verse(0));
     }
 
     @Ignore
@@ -55,7 +63,7 @@ public class BeerSongTest {
                         "Take it down and pass it around, no more bottles of beer on the wall.\n\n" +
                         "No more bottles of beer on the wall, no more bottles of beer.\n" +
                         "Go to the store and buy some more, 99 bottles of beer on the wall.\n\n",
-                BeerSong.sing(3,0));
+                beerSong.sing(3,0));
     }
 
     @Ignore
@@ -161,7 +169,7 @@ public class BeerSongTest {
                         "2 bottles of beer on the wall, 2 bottles of beer.\nTake one down and pass it around, 1 bottle of beer on the wall.\n\n" +
                         "1 bottle of beer on the wall, 1 bottle of beer.\nTake it down and pass it around, no more bottles of beer on the wall.\n\n" +
                         "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n\n",
-                BeerSong.singSong());
+                beerSong.singSong());
     }
 
 }

data/tracks/julia/img/icon.svg

@@ -1,11 +1,49 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 16.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 width="612px" height="792px" viewBox="0 0 612 792" enable-background="new 0 0 612 792" xml:space="preserve">
-<circle fill="#FFFFFF" stroke="#212121" stroke-width="12" stroke-miterlimit="10" cx="287.849" cy="338.754" r="219.026"/>
-<circle fill="#D71D4F" stroke="#212121" stroke-width="12" stroke-miterlimit="10" cx="180.973" cy="398.638" r="82.743"/>
-<circle fill="#FFFFFF" stroke="#212121" stroke-width="12" stroke-miterlimit="10" cx="287.849" cy="216.338" r="82.743"/>
-<circle fill="#212121" stroke="#212121" stroke-width="12" stroke-miterlimit="10" cx="393.733" cy="398.639" r="82.743"/>
-<circle fill="none" stroke="#FFFFFF" stroke-width="2" stroke-miterlimit="10" cx="393.733" cy="398.639" r="76.548"/>
-</svg>
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   version="1.1"
+   width="450.052"
+   height="450.052"
+   viewBox="0 0 450.052 450.052"
+   id="Layer_1"
+   xml:space="preserve"><metadata
+     id="metadata17"><rdf:RDF><cc:Work
+         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
+     id="defs15" /><circle
+     cx="287.849"
+     cy="338.754"
+     r="219.026"
+     transform="translate(-62.822998,-113.728)"
+     id="circle3"
+     style="fill:#ffffff;fill-opacity:1;stroke:#212121;stroke-width:12;stroke-miterlimit:10" /><circle
+     cx="180.97301"
+     cy="398.638"
+     r="82.742996"
+     transform="translate(-62.822998,-113.728)"
+     id="circle5"
+     style="fill:#d71d4f;stroke:#212121;stroke-width:12;stroke-miterlimit:10" /><circle
+     cx="287.849"
+     cy="216.338"
+     r="82.742996"
+     transform="translate(-62.822998,-113.728)"
+     id="circle7"
+     style="fill:#ffffff;stroke:#212121;stroke-width:12;stroke-miterlimit:10" /><circle
+     cx="393.733"
+     cy="398.63901"
+     r="82.742996"
+     transform="translate(-62.822998,-113.728)"
+     id="circle9"
+     style="fill:#212121;stroke:#212121;stroke-width:12;stroke-miterlimit:10" /><circle
+     cx="393.733"
+     cy="398.63901"
+     r="76.547997"
+     transform="matrix(0.97336202,0,0,0.95144158,-52.334748,-94.370717)"
+     id="circle11"
+     style="fill:none;stroke:#ffffff;stroke-width:3.0999999;stroke-miterlimit:10;stroke-dasharray:none" /></svg>