trackler 2.1.0.26 → 2.1.0.27

data/tracks/factor/README.md

@@ -1,4 +1,8 @@
-# xfactor
+# xFactor
+
+---
+
+[![Build Status](https://travis-ci.org/exercism/xfactor.svg?branch=master)](https://travis-ci.org/exercism/xfactor)
 
 Exercism problems in Factor.
 
@@ -35,9 +39,7 @@ Here's what you need to do to start working with the Factor code in the `exercis
 
   testing exercise: hello-world
 
-  Unit Test: { { "Hello, World!" } [ "" hello-you ] }
-  Unit Test: { { "Hello, Alice!" } [ "Alice" hello-you ] }
-  Unit Test: { { "Hello, Bob!" } [ "Bob" hello-you ] }
+  Unit Test: { { "Hello, World!" } [ say-hello ] }
   ```
 
   Alternatively, to run all tests in all exercise directories:
@@ -49,9 +51,7 @@ Here's what you need to do to start working with the Factor code in the `exercis
 
   testing exercise: hello-world
 
-  Unit Test: { { "Hello, World!" } [ "" hello-you ] }
-  Unit Test: { { "Hello, Alice!" } [ "Alice" hello-you ] }
-  Unit Test: { { "Hello, Bob!" } [ "Bob" hello-you ] }
+  Unit Test: { { "Hello, World!" } [ say-hello ] }
   ```
 
   `config.json` is verified for logical integrity on each run. To only check `config.json`'s validity:

data/tracks/factor/config.json

@@ -4,26 +4,35 @@
   "repository": "https://github.com/exercism/xfactor",
   "active": false,
   "test_pattern": "TODO",
+
   "exercises": [
     {
       "slug": "hello-world",
       "difficulty": 1,
       "topics": [
           "word definition",
-          "stack effect",
-          "text formatting",
-          "quotations"
+          "stack effect"
       ]
     },
     {
       "slug": "leap",
-      "difficulty": 2,
+      "difficulty": 3,
       "topics": [
         "quotations",
         "word definition",
         "conditionals",
         "logical operators"
       ]
+    },
+    {
+      "slug": "two-fer",
+      "difficulty": 2,
+      "topics": [
+          "word definition",
+          "stack effect",
+          "text formatting",
+          "quotations"
+      ]
     }
   ],
 

data/tracks/factor/exercises/hello-world/hello-world-example.factor

@@ -1,6 +1,5 @@
 USING: formatting kernel sequences ;
 IN: hello-world
 
-: hello-name ( name -- string )
-  dup empty? [ drop "World" ] when
-  "Hello, %s!" sprintf ;
+: say-hello ( -- string )
+  "Hello, World!" ;

data/tracks/factor/exercises/hello-world/hello-world-tests.factor

@@ -1,8 +1,4 @@
 USING: hello-world tools.test ;
 IN: hello-world.tests
 
-! There are no variadic functions in Factor, due to the nature of the stack.
-! Usually, if you need var args, use an array. Here, we'll just use an empty string.
-{ "Hello, World!" } [ ""      hello-name ] unit-test
-{ "Hello, Alice!" } [ "Alice" hello-name ] unit-test
-{ "Hello, Bob!"   } [ "Bob"   hello-name ] unit-test
+{ "Hello, World!" } [ say-hello ] unit-test

data/tracks/factor/exercises/hello-world/hello-world.factor

@@ -4,4 +4,4 @@ USING: ;
 IN: hello-world
 
 ! your implementation goes here
-! : hello-name ( -- ) ;
+! : say-hello ( -- ) ;

data/tracks/factor/exercises/two-fer/two-fer-example.factor

@@ -0,0 +1,6 @@
+USING: formatting kernel sequences ;
+IN: two-fer
+
+: 2-for-1 ( name -- string )
+  dup empty? [ drop "you" ] when
+  "One for %s, one for me." sprintf ;

data/tracks/factor/exercises/two-fer/two-fer-tests.factor

@@ -0,0 +1,8 @@
+USING: hello-world tools.test ;
+IN: two-fer.tests
+
+! There are no variadic functions in Factor, due to the nature of the stack.
+! Usually, if you need var args, use an array. Here, we'll just use an empty string.
+{ "One for you, one for me."   } [ ""      2-for-1 ] unit-test
+{ "One for Alice, one for me." } [ "Alice" 2-for-1 ] unit-test
+{ "One for Bob, one for me."   } [ "Bob"   2-for-1 ] unit-test

data/tracks/fortran/Makefile

@@ -30,8 +30,7 @@ install-test: ## install test dependency: funit
 
 test-assignment: ## run single test using ASSIGNMENTS: test-assignment ASSIGNMENT=wordy
 	@echo "running tests for: $(ASSIGNMENT)"
-#	@cat ./exercises/$(ASSIGNMENT)/$(TSTFILE) | sed '/markTestSkipped()/d' > $(OUTDIR)/$(TSTFILE)
-	@cat ./exercises/$(ASSIGNMENT)/$(TSTFILE) > $(OUTDIR)/$(TSTFILE)
+	@cat ./exercises/$(ASSIGNMENT)/$(TSTFILE) | sed 's/Xtest/test/' > $(OUTDIR)/$(TSTFILE)
 	@cp ./exercises/$(ASSIGNMENT)/$(EXAMPLE) $(OUTDIR)/$(ASSIGNMENT).$(FILEEXT)
 	@cd $(OUTDIR) && funit
 

data/tracks/fortran/config.json

@@ -16,6 +16,12 @@
       "difficulty": 1,
       "topics": [
       ]
+  },
+  {
+      "slug": "hamming",
+      "difficulty": 1,
+      "topics": [
+      ]
   }
   ],
   "deprecated": [

data/tracks/fortran/exercises/bob/bob.fun

@@ -38,75 +38,75 @@ test stating_something
   assert_equal( 'Whatever.' , hey('Tom-ay-to, tomaaaah-to.') )
 end test
 
-test shouting
+Xtest shouting
   assert_equal( 'Whoa chill out!' , hey('WATCH OUT!') )
 end test
 
-test shouting_gibberish
+Xtest shouting_gibberish
   assert_equal( 'Whoa chill out!' , hey(random_shouting(11)) )
 end test
 
-test asking_a_question
+Xtest asking_a_question
   assert_equal( 'Sure.' , hey('Does this cryogenic chamber make me look fat?') )
 end test
 
-test asking_a_numeric_question
+Xtest asking_a_numeric_question
   assert_equal( 'Sure.' , hey('You are, what, like 15?') )
 end test
 
-test asking_gibberish
+Xtest asking_gibberish
   assert_equal( 'Sure.' , hey(random_question(11)) )
 end test
 
-test talking_forcefully
+Xtest talking_forcefully
   assert_equal( 'Whatever.' , hey('Lets''s go make out behind the gym!') )
 end test
 
-test using_acronyms_in_regular_speech
+Xtest using_acronyms_in_regular_speech
   assert_equal( 'Whatever.' , hey('It''s OK if you don''t want to go to the DMV.') )
 end test
 
-test forceful_questions
+Xtest forceful_questions
   assert_equal( 'Whoa chill out!' , hey('WHAT THE HELL WHERE YOU THINKING?') )
 end test
 
-test shouting_numbers
+Xtest shouting_numbers
   assert_equal( 'Whoa chill out!' , hey('1, 2, 3, GO!') )
 end test
 
-test only_numbers
+Xtest only_numbers
   assert_equal( 'Whatever.' , hey('1, 2, 3') )
 end test
 
-test questions_with_only_numbers
+Xtest questions_with_only_numbers
   assert_equal( 'Sure.' , hey('4?') )
 end test
 
-test shouting_with_special_characters
+Xtest shouting_with_special_characters
   assert_equal( 'Whoa chill out!' , hey('ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!') )
 end test
 
-test shouting_with_no_exclamation_mark
+Xtest shouting_with_no_exclamation_mark
   assert_equal( 'Whoa chill out!' , hey('I HATE YOU') )
 end test
 
-test statement_containing_exclamation_mark
+Xtest statement_containing_exclamation_mark
   assert_equal( 'Whatever.' , hey('Ending with ? means a question.') )
 end test
 
-test prattling_on
+Xtest prattling_on
   assert_equal( 'Sure.' , hey('Wait! Hang on. Are you going to ge OK?') )
 end test
 
-test silence
+Xtest silence
   assert_equal( 'Fine. Be that way!' , hey('') )
 end test
 
-test prolonged_silence
+Xtest prolonged_silence
   assert_equal( 'Fine. Be that way!' , hey('     ') )
 end test
 
-test on_multiple_line_questions
+Xtest on_multiple_line_questions
   multi_line_string = ''//NEW_LINE('A')//'Does this cryogenic chamber make me look fat?'//NEW_LINE('A')//'no'
   assert_equal( 'Whatever.' , hey(multi_line_string) )
 end test

data/tracks/fortran/exercises/hamming/example.f90

@@ -0,0 +1,25 @@
+module hamming
+contains
+
+  function compute(strand1, strand2, distance)
+      character(*) :: strand1, strand2
+      integer :: distance, i
+      logical :: compute
+
+      distance = 0
+      compute = .true.
+
+      if ( len(strand1) .NE. len(strand2) ) then
+          compute = .false.
+          return
+      end if
+
+      do i = 1,len(strand1)
+        if (strand1(i:i) .NE. strand2(i:i)) then
+          distance = distance + 1
+        end if
+
+      end do
+
+  end function compute
+end module hamming

data/tracks/fortran/exercises/hamming/hamming.fun

@@ -0,0 +1,75 @@
+test_suite hamming
+  integer :: distance
+
+setup
+end setup
+
+test identical_strands
+  assert_true( compute('A', 'A', distance ) )
+  assert_equal( 0, distance )
+end test
+
+Xtest long_identical_strands
+  assert_true( compute('GGACTGA', 'GGACTGA', distance ) )
+  assert_equal( 0, distance )
+end test
+
+Xtest complete_distance_in_single_nucleotide_strands
+  assert_true( compute('A', 'G', distance) )
+  assert_equal( 1, distance )
+end test
+
+Xtest complete_distance_in_small_strands
+  assert_true( compute('AG', 'CT', distance) )
+  assert_equal( 2, distance )
+end test
+
+Xtest small_distance_in_small_strands
+  assert_true( compute('AT', 'CT', distance) )
+  assert_equal( 1, distance )
+end test
+
+Xtest small_distance
+  assert_true( compute('GGACG', 'GGTCG', distance) )
+  assert_equal( 1, distance )
+end test
+
+Xtest small_distance_in_long_strands
+  assert_true( compute('ACCAGGG', 'ACTATGG', distance) )
+  assert_equal( 2, distance )
+end test
+
+Xtest non_unique_character_in_first_strand
+  assert_true( compute('AGA', 'AGG', distance) )
+  assert_equal( 1, distance )
+end test
+
+Xtest same_nucleotides_in_different_positions
+  assert_true( compute('TAG', 'GAT', distance) )
+  assert_equal( 2, distance )
+end test
+
+Xtest large_distance
+  assert_true( compute('GATACA', 'GCATAA', distance) )
+  assert_equal( 4, distance )
+end test
+
+Xtest large_distance_in_off_by_one_strand
+  assert_true( compute('GGACGGATTCTG', 'AGGACGGATTCT', distance) )
+  assert_equal( 9, distance )
+end test
+
+Xtest empty_strands
+  assert_true( compute('', '', distance) )
+  assert_equal( 0, distance )
+end test
+
+Xtest disallow_first_strand_longer
+  assert_false( compute('AATG', 'AAA', distance) )
+end test
+
+Xtest disallow_second_strand_longer
+  assert_false( compute('ATA', 'AGTG', distance) )
+end test
+
+end test_suite

data/tracks/go/exercises/poker/.meta/gen.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"log"
+	"strings"
+	"text/template"
+
+	"../../../gen"
+)
+
+func main() {
+	t := template.New("").Funcs(template.FuncMap{
+		"pokerHands": PokerHands,
+	})
+	t, err := t.Parse(tmpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var j js
+	if err := gen.Gen("poker", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Cases []struct {
+		Description string
+		Input       []string
+		Expected    []string
+	}
+}
+
+var suitCharToSymbol = map[byte]string{'C': "♧", 'D': "♢", 'H': "♡", 'S': "♤"}
+
+// PokerHands converts hands using C/D/H/S as the suit
+// to one which uses the symbols ♧ / ♢ / ♡ / ♤ instead.
+// For example, "2H 3C 4D 5S 9S" is converted to "2♡ 3♧ 4♢ 5♤ 9♤".
+func PokerHands(inputHands []string) []string {
+	hands := make([]string, len(inputHands))
+	for i, inputHand := range inputHands {
+		cards := strings.Fields(inputHand)
+		handStr := ""
+		for j, c := range cards {
+			rankStr := c[0 : len(c)-1]
+			handStr += rankStr + suitCharToSymbol[c[len(c)-1]]
+			if j != len(cards)-1 {
+				handStr += " "
+			}
+		}
+		hands[i] = handStr
+	}
+	return hands
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package poker
+
+{{.Header}}
+
+type validTestCase struct {
+	name  string
+	hands []string
+	best  []string
+}
+
+var validTestCases = []validTestCase {
+{{range .J.Cases}}{
+	name:  "{{.Description}}",
+	hands: []string{
+		{{range pokerHands .Input}} {{printf "%q" .}},
+{{end}} },
+	best:  {{pokerHands .Expected | printf "%#v"}},
+},
+{{end}}}
+`

data/tracks/go/exercises/poker/cases_test.go

@@ -0,0 +1,240 @@
+package poker
+
+// Source: exercism/x-common
+// Commit: d078ba8 poker: Add canonical-data (#793)
+// x-common version: 1.0.0
+
+type validTestCase struct {
+	name  string
+	hands []string
+	best  []string
+}
+
+var validTestCases = []validTestCase{
+	{
+		name: "single hand always wins",
+		hands: []string{
+			"4♤ 5♤ 7♡ 8♢ J♧",
+		},
+		best: []string{"4♤ 5♤ 7♡ 8♢ J♧"},
+	},
+	{
+		name: "highest card out of all hands wins",
+		hands: []string{
+			"4♢ 5♤ 6♤ 8♢ 3♧",
+			"2♤ 4♧ 7♤ 9♡ 10♡",
+			"3♤ 4♤ 5♢ 6♡ J♡",
+		},
+		best: []string{"3♤ 4♤ 5♢ 6♡ J♡"},
+	},
+	{
+		name: "a tie has multiple winners",
+		hands: []string{
+			"4♢ 5♤ 6♤ 8♢ 3♧",
+			"2♤ 4♧ 7♤ 9♡ 10♡",
+			"3♤ 4♤ 5♢ 6♡ J♡",
+			"3♡ 4♡ 5♧ 6♧ J♢",
+		},
+		best: []string{"3♤ 4♤ 5♢ 6♡ J♡", "3♡ 4♡ 5♧ 6♧ J♢"},
+	},
+	{
+		name: "multiple hands with the same high cards, tie compares next highest ranked, down to last card",
+		hands: []string{
+			"3♤ 5♡ 6♤ 8♢ 7♡",
+			"2♤ 5♢ 6♢ 8♧ 7♤",
+		},
+		best: []string{"3♤ 5♡ 6♤ 8♢ 7♡"},
+	},
+	{
+		name: "one pair beats high card",
+		hands: []string{
+			"4♤ 5♡ 6♧ 8♢ K♡",
+			"2♤ 4♡ 6♤ 4♢ J♡",
+		},
+		best: []string{"2♤ 4♡ 6♤ 4♢ J♡"},
+	},
+	{
+		name: "highest pair wins",
+		hands: []string{
+			"4♤ 2♡ 6♤ 2♢ J♡",
+			"2♤ 4♡ 6♧ 4♢ J♢",
+		},
+		best: []string{"2♤ 4♡ 6♧ 4♢ J♢"},
+	},
+	{
+		name: "two pairs beats one pair",
+		hands: []string{
+			"2♤ 8♡ 6♤ 8♢ J♡",
+			"4♤ 5♡ 4♧ 8♧ 5♧",
+		},
+		best: []string{"4♤ 5♡ 4♧ 8♧ 5♧"},
+	},
+	{
+		name: "both hands have two pairs, highest ranked pair wins",
+		hands: []string{
+			"2♤ 8♡ 2♢ 8♢ 3♡",
+			"4♤ 5♡ 4♧ 8♤ 5♢",
+		},
+		best: []string{"2♤ 8♡ 2♢ 8♢ 3♡"},
+	},
+	{
+		name: "both hands have two pairs, with the same highest ranked pair, tie goes to low pair",
+		hands: []string{
+			"2♤ Q♤ 2♧ Q♢ J♡",
+			"J♢ Q♡ J♤ 8♢ Q♧",
+		},
+		best: []string{"J♢ Q♡ J♤ 8♢ Q♧"},
+	},
+	{
+		name: "both hands have two identically ranked pairs, tie goes to remaining card (kicker)",
+		hands: []string{
+			"J♢ Q♡ J♤ 8♢ Q♧",
+			"J♤ Q♤ J♧ 2♢ Q♢",
+		},
+		best: []string{"J♢ Q♡ J♤ 8♢ Q♧"},
+	},
+	{
+		name: "three of a kind beats two pair",
+		hands: []string{
+			"2♤ 8♡ 2♡ 8♢ J♡",
+			"4♤ 5♡ 4♧ 8♤ 4♡",
+		},
+		best: []string{"4♤ 5♡ 4♧ 8♤ 4♡"},
+	},
+	{
+		name: "both hands have three of a kind, tie goes to highest ranked triplet",
+		hands: []string{
+			"2♤ 2♡ 2♧ 8♢ J♡",
+			"4♤ A♡ A♤ 8♧ A♢",
+		},
+		best: []string{"4♤ A♡ A♤ 8♧ A♢"},
+	},
+	{
+		name: "with multiple decks, two players can have same three of a kind, ties go to highest remaining cards",
+		hands: []string{
+			"4♤ A♡ A♤ 7♧ A♢",
+			"4♤ A♡ A♤ 8♧ A♢",
+		},
+		best: []string{"4♤ A♡ A♤ 8♧ A♢"},
+	},
+	{
+		name: "a straight beats three of a kind",
+		hands: []string{
+			"4♤ 5♡ 4♧ 8♢ 4♡",
+			"3♤ 4♢ 2♤ 6♢ 5♧",
+		},
+		best: []string{"3♤ 4♢ 2♤ 6♢ 5♧"},
+	},
+	{
+		name: "aces can end a straight (10 J Q K A)",
+		hands: []string{
+			"4♤ 5♡ 4♧ 8♢ 4♡",
+			"10♢ J♡ Q♤ K♢ A♧",
+		},
+		best: []string{"10♢ J♡ Q♤ K♢ A♧"},
+	},
+	{
+		name: "aces can start a straight (A 2 3 4 5)",
+		hands: []string{
+			"4♤ 5♡ 4♧ 8♢ 4♡",
+			"4♢ A♡ 3♤ 2♢ 5♧",
+		},
+		best: []string{"4♢ A♡ 3♤ 2♢ 5♧"},
+	},
+	{
+		name: "both hands with a straight, tie goes to highest ranked card",
+		hands: []string{
+			"4♤ 6♧ 7♤ 8♢ 5♡",
+			"5♤ 7♡ 8♤ 9♢ 6♡",
+		},
+		best: []string{"5♤ 7♡ 8♤ 9♢ 6♡"},
+	},
+	{
+		name: "even though an ace is usually high, a 5-high straight is the lowest-scoring straight",
+		hands: []string{
+			"2♡ 3♧ 4♢ 5♢ 6♡",
+			"4♤ A♡ 3♤ 2♢ 5♡",
+		},
+		best: []string{"2♡ 3♧ 4♢ 5♢ 6♡"},
+	},
+	{
+		name: "flush beats a straight",
+		hands: []string{
+			"4♧ 6♡ 7♢ 8♢ 5♡",
+			"2♤ 4♤ 5♤ 6♤ 7♤",
+		},
+		best: []string{"2♤ 4♤ 5♤ 6♤ 7♤"},
+	},
+	{
+		name: "both hands have a flush, tie goes to high card, down to the last one if necessary",
+		hands: []string{
+			"4♡ 7♡ 8♡ 9♡ 6♡",
+			"2♤ 4♤ 5♤ 6♤ 7♤",
+		},
+		best: []string{"4♡ 7♡ 8♡ 9♡ 6♡"},
+	},
+	{
+		name: "full house beats a flush",
+		hands: []string{
+			"3♡ 6♡ 7♡ 8♡ 5♡",
+			"4♤ 5♡ 4♧ 5♢ 4♡",
+		},
+		best: []string{"4♤ 5♡ 4♧ 5♢ 4♡"},
+	},
+	{
+		name: "both hands have a full house, tie goes to highest-ranked triplet",
+		hands: []string{
+			"4♡ 4♤ 4♢ 9♤ 9♢",
+			"5♡ 5♤ 5♢ 8♤ 8♢",
+		},
+		best: []string{"5♡ 5♤ 5♢ 8♤ 8♢"},
+	},
+	{
+		name: "with multiple decks, both hands have a full house with the same triplet, tie goes to the pair",
+		hands: []string{
+			"5♡ 5♤ 5♢ 9♤ 9♢",
+			"5♡ 5♤ 5♢ 8♤ 8♢",
+		},
+		best: []string{"5♡ 5♤ 5♢ 9♤ 9♢"},
+	},
+	{
+		name: "four of a kind beats a full house",
+		hands: []string{
+			"4♤ 5♡ 4♢ 5♢ 4♡",
+			"3♤ 3♡ 2♤ 3♢ 3♧",
+		},
+		best: []string{"3♤ 3♡ 2♤ 3♢ 3♧"},
+	},
+	{
+		name: "both hands have four of a kind, tie goes to high quad",
+		hands: []string{
+			"2♤ 2♡ 2♧ 8♢ 2♢",
+			"4♤ 5♡ 5♤ 5♢ 5♧",
+		},
+		best: []string{"4♤ 5♡ 5♤ 5♢ 5♧"},
+	},
+	{
+		name: "with multiple decks, both hands with identical four of a kind, tie determined by kicker",
+		hands: []string{
+			"3♤ 3♡ 2♤ 3♢ 3♧",
+			"3♤ 3♡ 4♤ 3♢ 3♧",
+		},
+		best: []string{"3♤ 3♡ 4♤ 3♢ 3♧"},
+	},
+	{
+		name: "straight flush beats four of a kind",
+		hands: []string{
+			"4♤ 5♡ 5♤ 5♢ 5♧",
+			"7♤ 8♤ 9♤ 6♤ 10♤",
+		},
+		best: []string{"7♤ 8♤ 9♤ 6♤ 10♤"},
+	},
+	{
+		name: "both hands have straight flush, tie goes to highest-ranked card",
+		hands: []string{
+			"4♡ 6♡ 7♡ 8♡ 5♡",
+			"5♤ 7♤ 8♤ 9♤ 6♤",
+		},
+		best: []string{"5♤ 7♤ 8♤ 9♤ 6♤"},
+	},
+}