trackler 2.2.1.82 → 2.2.1.83

data/tracks/go/exercises/pig-latin/cases_test.go

@@ -0,0 +1,122 @@
+package piglatin
+
+// Source: exercism/problem-specifications
+// Commit: b5ddd0a pig-latin: tests for Y as a vowel (#904)
+// Problem Specifications Version: 1.1.0
+
+var testCases = []struct {
+	description string
+	input       string
+	expected    string
+}{
+	{
+		description: "word beginning with a",
+		input:       "apple",
+		expected:    "appleay",
+	},
+	{
+		description: "word beginning with e",
+		input:       "ear",
+		expected:    "earay",
+	},
+	{
+		description: "word beginning with i",
+		input:       "igloo",
+		expected:    "iglooay",
+	},
+	{
+		description: "word beginning with o",
+		input:       "object",
+		expected:    "objectay",
+	},
+	{
+		description: "word beginning with u",
+		input:       "under",
+		expected:    "underay",
+	},
+	{
+		description: "word beginning with a vowel and followed by a qu",
+		input:       "equal",
+		expected:    "equalay",
+	},
+	{
+		description: "word beginning with p",
+		input:       "pig",
+		expected:    "igpay",
+	},
+	{
+		description: "word beginning with k",
+		input:       "koala",
+		expected:    "oalakay",
+	},
+	{
+		description: "word beginning with x",
+		input:       "xenon",
+		expected:    "enonxay",
+	},
+	{
+		description: "word beginning with q without a following u",
+		input:       "qat",
+		expected:    "atqay",
+	},
+	{
+		description: "word beginning with ch",
+		input:       "chair",
+		expected:    "airchay",
+	},
+	{
+		description: "word beginning with qu",
+		input:       "queen",
+		expected:    "eenquay",
+	},
+	{
+		description: "word beginning with qu and a preceding consonant",
+		input:       "square",
+		expected:    "aresquay",
+	},
+	{
+		description: "word beginning with th",
+		input:       "therapy",
+		expected:    "erapythay",
+	},
+	{
+		description: "word beginning with thr",
+		input:       "thrush",
+		expected:    "ushthray",
+	},
+	{
+		description: "word beginning with sch",
+		input:       "school",
+		expected:    "oolschay",
+	},
+	{
+		description: "word beginning with yt",
+		input:       "yttria",
+		expected:    "yttriaay",
+	},
+	{
+		description: "word beginning with xr",
+		input:       "xray",
+		expected:    "xrayay",
+	},
+	{
+		description: "y is treated like a consonant at the beginning of a word",
+		input:       "yellow",
+		expected:    "ellowyay",
+	},
+	{
+		description: "y is treated like a vowel at the end of a consonant cluster",
+		input:       "rhythm",
+		expected:    "ythmrhay",
+	},
+	{
+		description: "y as second letter in two letter word",
+		input:       "my",
+		expected:    "ymay",
+	},
+	{
+		description: "a whole phrase",
+		input:       "quick fast run",
+		expected:    "ickquay astfay unray",
+	},
+}

data/tracks/go/exercises/pig-latin/example.go

@@ -1,4 +1,4 @@
-package igpay
+package piglatin
 
 import (
 	"regexp"
@@ -7,16 +7,28 @@ import (
 
 var vowel = regexp.MustCompile(`^([aeiou]|y[^aeiou]|xr)[a-z]*`)
 var cons = regexp.MustCompile(`^([^aeiou]?qu|[^aeiou]+)([a-z]*)`)
+var containsy = regexp.MustCompile(`^([^aeiou]+)y([a-z]*)`)
 
-func PigLatin(s string) string {
+// Sentence translates a whole sentence in piglatin
+func Sentence(s string) string {
 	sw := strings.Fields(s)
 	for i, w := range sw {
-		l := strings.ToLower(w)
-		if vowel.MatchString(l) {
-			sw[i] = l + "ay"
-		} else if x := cons.FindStringSubmatchIndex(l); x != nil {
-			sw[i] = l[x[3]:] + l[:x[3]] + "ay"
-		}
+		sw[i] = Word(strings.ToLower(w))
 	}
 	return strings.Join(sw, " ")
 }
+
+// Word translates a single word
+func Word(s string) (result string) {
+	//special case for y as a vowel
+	if containsy.MatchString(s) {
+		pos := containsy.FindStringSubmatchIndex(s)
+		return s[pos[3]:] + s[:pos[3]] + "ay"
+	}
+	if vowel.MatchString(s) {
+		result = s + "ay"
+	} else if x := cons.FindStringSubmatchIndex(s); x != nil {
+		result = s[x[3]:] + s[:x[3]] + "ay"
+	}
+	return result
+}

data/tracks/go/exercises/pig-latin/pig_latin_test.go

@@ -1,29 +1,15 @@
-package igpay
+package piglatin
 
-import "testing"
-
-var tests = []struct{ pl, in string }{
-	{"appleay", "apple"},
-	{"earay", "ear"},
-	{"igpay", "pig"},
-	{"oalakay", "koala"},
-	{"airchay", "chair"},
-	{"eenquay", "queen"},
-	{"aresquay", "square"},
-	{"erapythay", "therapy"},
-	{"ushthray", "thrush"},
-	{"oolschay", "school"},
-	{"ickquay astfay unray", "quick fast run"},
-	{"ellowyay", "yellow"},
-	{"yttriaay", "yttria"},
-	{"enonxay", "xenon"},
-	{"xrayay", "xray"},
-}
+import (
+	"fmt"
+	"testing"
+)
 
 func TestPigLatin(t *testing.T) {
-	for _, test := range tests {
-		if pl := PigLatin(test.in); pl != test.pl {
-			t.Fatalf("PigLatin(%q) = %q, want %q.", test.in, pl, test.pl)
+	for _, test := range testCases {
+		if pl := Sentence(test.input); pl != test.expected {
+			t.Fatalf("FAIL: Sentence(%q) = %q, want %q.", test.input, pl, test.expected)
 		}
+		fmt.Printf("PASS: %s\n", test.description)
 	}
 }

data/tracks/java/exercises/acronym/.meta/src/reference/java/Acronym.java

@@ -1,5 +1,5 @@
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
+import java.util.Arrays;
+import java.util.stream.Collectors;
 
 final class Acronym {
 
@@ -13,14 +13,12 @@ final class Acronym {
         return acronym;
     }
 
-    private String generateAcronym(String phrase){
-        final Pattern BREAK_WORDS = Pattern.compile("[A-Z]+[a-z]*|[a-z]+");
-        final Matcher matcher = BREAK_WORDS.matcher(phrase);
-        final StringBuilder stringBuilder = new StringBuilder();
-        while (matcher.find()){
-            stringBuilder.append(matcher.group().charAt(0));
-        }
-        return stringBuilder.toString().toUpperCase();
+    private String generateAcronym(String phrase) {
+        return Arrays.stream(phrase.split("[^a-zA-Z]"))
+                .filter(word -> !word.isEmpty()) // Remove empty strings from the result of phrase.split
+                .map(word -> word.substring(0, 1)) // Get the first character of each word
+                .collect(Collectors.joining()) // Concatenate the characters
+                .toUpperCase();
     }
 
 }

data/tracks/java/exercises/anagram/.meta/src/reference/java/Anagram.java

@@ -1,4 +1,5 @@
 import java.util.*;
+import java.util.stream.Collectors;
 
 class Anagram {
 
@@ -9,15 +10,9 @@ class Anagram {
     }
 
     List<String> match(List<String> candidates) {
-        List<String> anagrams = new ArrayList<String>();
-
-        for (String candidate : candidates) {
-            if (anagramSubject.anagramOf(candidate)) {
-                anagrams.add(candidate);
-            }
-        }
-
-        return anagrams;
+        return candidates.stream()
+                .filter(anagramSubject::anagramOf)
+                .collect(Collectors.toList());
     }
 
     static final class AnagramSubject {

data/tracks/java/exercises/atbash-cipher/.meta/src/reference/java/Atbash.java

@@ -30,15 +30,7 @@ class Atbash {
     }
 
     private String stripInvalidCharacters(String input) {
-        StringBuilder filteredValue = new StringBuilder(input.length());
-
-        for (char c : input.toCharArray()) {
-            if (Character.isLetterOrDigit(c)) {
-                filteredValue.append(c);
-            }
-        }
-
-        return filteredValue.toString();
+        return input.replaceAll("\\W", "");
     }
 
     private char applyCipher(char input) {
@@ -51,7 +43,7 @@ class Atbash {
         List<String> words = new ArrayList<>();
 
         for (int i = 0; i < value.length(); i += GROUP_SIZE) {
-            words.add(i + GROUP_SIZE <= value.length() ? value.substring(i, i + GROUP_SIZE) : value.substring(i));
+            words.add(value.substring(i, Math.min(value.length(), i + GROUP_SIZE)));
         }
 
         return String.join(" ", words);

data/tracks/java/exercises/hamming/.meta/version

@@ -1 +1 @@
-1.1.0
+2.0.1

data/tracks/java/exercises/hamming/src/test/java/HammingTest.java

@@ -5,6 +5,7 @@ import org.junit.rules.ExpectedException;
 
 import static org.junit.Assert.assertEquals;
 
+
 public class HammingTest {
 
     @Rule
@@ -60,13 +61,13 @@ public class HammingTest {
     @Ignore("Remove to run test")
     @Test
     public void testNonUniqueCharacterInFirstStrand() {
-        assertEquals(1, new Hamming("AGA", "AGG").getHammingDistance());
+        assertEquals(1, new Hamming("AAG", "AAA").getHammingDistance());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testNonUniqueCharacterInSecondStrand() {
-        assertEquals(1, new Hamming("AGG", "AGA").getHammingDistance());
+        assertEquals(1, new Hamming("AAA", "AAG").getHammingDistance());
     }
 
     @Ignore("Remove to run test")

data/tracks/java/exercises/isogram/.meta/version

@@ -0,0 +1 @@
+1.2.0

data/tracks/java/exercises/isogram/src/test/java/IsogramCheckerTest.java

@@ -6,9 +6,16 @@ import static org.junit.Assert.*;
 public class IsogramCheckerTest {
 
     @Test
-    public void testIsogram() {
+    public void testEmptyString() {
         IsogramChecker iso = new IsogramChecker();
-        assertTrue(iso.isIsogram("duplicates"));
+        assertTrue(iso.isIsogram(""));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLowercaseIsogram() {
+        IsogramChecker iso = new IsogramChecker();
+        assertTrue(iso.isIsogram("isogram"));
     }
 
     @Ignore("Remove to run test")
@@ -41,37 +48,23 @@ public class IsogramCheckerTest {
 
     @Ignore("Remove to run test")
     @Test
-    public void testIgnoresMultipleHyphens() {
-        IsogramChecker iso = new IsogramChecker();
-        assertTrue(iso.isIsogram("Hjelmqvist-Gryb-Zock-Pfund-Wax"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testWorksWithGermanLetters() {
-        IsogramChecker iso = new IsogramChecker();
-        assertTrue(iso.isIsogram("Heizölrückstoßabdämpfung"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testIgnoresSpaces() {
+    public void testIsogramWithDuplicatedHyphen() {
         IsogramChecker iso = new IsogramChecker();
-        assertFalse(iso.isIsogram("the quick brown fox"));
+        assertTrue(iso.isIsogram("six-year-old"));
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testIgnoresSpaces2() {
+    public void testMadeUpNameThatIsAnIsogram() {
         IsogramChecker iso = new IsogramChecker();
         assertTrue(iso.isIsogram("Emily Jung Schwartzkopf"));
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testDuplicateAccentedLetters() {
+    public void testDuplicatedCharacterInTheMiddleIsNotIsogram() {
         IsogramChecker iso = new IsogramChecker();
-        assertFalse(iso.isIsogram("éléphant"));
+        assertFalse(iso.isIsogram("accentor"));
     }
 
 }

data/tracks/ruby/config.json

@@ -887,7 +887,7 @@
       ]
     },
     {
-      "uuid": "b02a4214-0f1a-9480-2132-2ea3d5073dbfbec0aa4",
+      "uuid": "1304b188-6d08-4361-be40-c6b1b88e5e54",
       "slug": "two-fer",
       "core": false,
       "unlocked_by": null,
@@ -908,7 +908,7 @@
       "deprecated": true
     },
     {
-      "uuid": "4ca1322e-0c39-1e80-91e9-6b3f9ccf894f9058490",
+      "uuid": "d75bd7c0-52c5-44f2-a046-f63cb332425f",
       "slug": "complex-numbers",
       "difficulty": 3,
       "topics": [ "Mathematics" ]
@@ -923,6 +923,18 @@
         "strings",
         "logic"
       ]
+    },
+    {
+      "uuid": "0ec96460-08be-49a0-973a-4336f21b763c",
+      "slug": "book-store",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 6,
+      "topics": [
+        "loops",
+        "arrays",
+        "logic"
+      ]
     }
   ],
   "foregone": [

data/tracks/ruby/exercises/book-store/.meta/generator/book_store_case.rb

@@ -0,0 +1,9 @@
+require 'generator/exercise_case'
+
+class BookStoreCase < Generator::ExerciseCase
+
+  def workload
+    assert_equal { "BookStore.calculate_price(#{basket})" }
+  end
+
+end

data/tracks/ruby/exercises/book-store/.meta/solutions/.version

@@ -0,0 +1 @@
+0

data/tracks/ruby/exercises/book-store/.meta/solutions/book_store.rb

@@ -0,0 +1,47 @@
+module BookKeeping
+  VERSION = 0
+end
+
+class BookStore
+
+  GROUP_DISCOUNTS = [0, 0.05, 0.1, 0.2, 0.25]
+  INDIVIDUAL_PRICE = 8
+
+  def self.calculate_price(basket)
+    groups = []
+    remaining_books = basket.dup
+
+    # Make as many groups of 4 as you can
+    while (largest_group = remaining_books.uniq).length > 3
+      group_of_four = largest_group[0..3]
+      group_of_four.each {|book| remaining_books.delete_at(remaining_books.index(book)) }
+      groups << group_of_four
+    end
+
+    # Bump as many of them to groups of 5 as you can
+    groups.each do |group|
+      fifth_book = (remaining_books - group).first
+      next unless fifth_book
+
+      group << fifth_book
+      remaining_books.delete_at(remaining_books.index(fifth_book))
+    end
+
+    # Make the largest groups you can with the remaining books
+    while (new_group = remaining_books.uniq).any?
+      new_group.each {|book| remaining_books.delete_at(remaining_books.index(book)) }
+      groups << new_group
+    end
+
+    groups.map {|group| group_price(group.length) }.inject(0,:+)
+  end
+
+  private
+
+  def self.group_price(group_size)
+    discount = GROUP_DISCOUNTS[group_size - 1]
+
+    group_size * INDIVIDUAL_PRICE * (1 - discount)
+  end
+
+end