trackler 1.0.0 → 1.0.0.1

data/tracks/haskell/exercises/leap/HINTS.md

@@ -0,0 +1,11 @@
+## Hints
+
+To complete this exercise you need to implement the function `isLeapYear`,
+that takes a year and determines whether it is a leap year.
+
+You can use the provided signature if you are unsure about the types, but
+don't let it restrict your creativity:
+
+```haskell
+isLeapYear :: Integer -> Bool
+```

data/tracks/haskell/exercises/leap/src/LeapYear.hs

@@ -1,3 +1,4 @@
 module LeapYear (isLeapYear) where
 
+isLeapYear :: Integer -> Bool
 isLeapYear = undefined

data/tracks/java/exercises/pangram/src/test/java/PangramTest.java

@@ -8,13 +8,13 @@ public class PangramTest {
 
 
     @Test
-    public void emptySentence() {
+    public void sentenceEmpty() {
         assertFalse(Pangrams.isPangram(""));
     }
 
     @Ignore
     @Test
-    public void testLowercasePangram() {
+    public void pangramWithOnlyLowerCase() {
         assertTrue(Pangrams.isPangram("the quick brown fox jumps over the lazy dog"));
     }
 
@@ -26,14 +26,44 @@ public class PangramTest {
 
     @Ignore
     @Test
-    public void mixedCaseAndPunctuation() {
+    public void anotherMissingCharacterX() {
+        assertFalse(Pangrams.isPangram("the quick brown fish jumps over the lazy dog"));
+    }
+
+    @Ignore
+    @Test
+    public void pangramWithUnderscores() {
+        assertTrue(Pangrams.isPangram("\"the_quick_brown_fox_jumps_over_the_lazy_dog\""));
+    }
+
+    @Ignore
+    @Test
+    public void pangramWithNumbers() {
+        assertTrue(Pangrams.isPangram("\"the 1 quick brown fox jumps over the 2 lazy dogs\""));
+    }
+
+    @Ignore
+    @Test
+    public void missingLettersReplacedByNumbers() {
+        assertFalse(Pangrams.isPangram("\"7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog\""));
+    }
+
+    @Ignore
+    @Test
+    public void pangramWithMixedCaseAndPunctuation() {
         assertTrue(Pangrams.isPangram("\"Five quacking Zephyrs jolt my wax bed.\""));
     }
 
     @Ignore
     @Test
-    public void nonAsciiCharacters() {
+    public void pangramWithNonAsciiCharacters() {
         assertTrue(Pangrams.isPangram("Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich."));
     }
 
+
+    @Ignore
+    @Test
+    public void panagramInAlphabetOtherThanAscii() {
+        assertFalse(Pangrams.isPangram("Широкая электрификация южных губерний даст мощный толчок подъёму сельского хозяйства."));
+    }
 }

data/tracks/lua/exercises/pov/pov_spec.lua

@@ -2,9 +2,7 @@ local pov_from = require('pov').pov_from
 local path_from = require('pov').path_from
 
 describe('pov', function()
-
   describe('pov_from.of', function()
-
     it('should give the POV of a singleton as the singleton', function()
       assert.same({ 'x' }, pov_from('x').of({ 'x' }))
     end)
@@ -22,13 +20,6 @@ describe('pov', function()
       assert.same(expected, pov_from('leaf').of(simple_tree))
     end)
 
-    it('should be able give the POV of a leaf in a simple tree', function()
-      local simple_tree = { 'parent', {{ 'sibling' }, { 'leaf' }}}
-      local expected = { 'leaf', {{ 'parent', {{ 'sibling' }}}}}
-
-      assert.same(expected, pov_from('leaf').of(simple_tree))
-    end)
-
     it('should be able give the POV of the leaf of a deeply nested tree', function()
       local deeply_nested_tree =
         { 'level1', {
@@ -124,11 +115,9 @@ describe('pov', function()
       pov_from('leaf').of(tree)
       assert.same(original_tree, tree)
     end)
-
   end)
 
   describe('path_from.to.of', function()
-
     it('should be able to give the path from a leaf to the root of a simple tree', function()
       local simple_tree =
         { 'parent', {
@@ -189,7 +178,5 @@ describe('pov', function()
       path_from('leaf').to('parent').of(tree)
       assert.same(original_tree, tree)
     end)
-
   end)
-
 end)

data/tracks/mips/docs/ABOUT.md

@@ -1,3 +1,3 @@
-MIPS is a reduced instruction set computer (RISC) instruction set architecture, currently used mostly in video game consoles and and routers. It is also a popular architecture in introductory courses and textbooks on computer architecture, due to its simplicity relative to x86 and ARM. Here we use the 32-bit instruction set; a 64-bit instruction set also exists.
+MIPS is a reduced instruction set computer (RISC) instruction set architecture, currently used mostly in video game consoles and routers. It is also a popular architecture in introductory courses and textbooks on computer architecture, due to its simplicity relative to x86 and ARM. Here we use the 32-bit instruction set; a 64-bit instruction set also exists.
 
 This track involves programming in MIPS assembly language, assembled and run on a cross-platform simulator.

data/tracks/objective-c/config.json

@@ -31,6 +31,231 @@
     ,"secret-handshake"
     ,"acronym"
     ,"run-length-encoding"
+    ,"largest-series-product"
+  ],
+  "exercises": [
+    {
+        "difficulty": 1,
+        "slug": "hello-world",
+        "topics": [
+            "Text formatting",
+            "Optional values"
+        ]
+    },
+    {
+        "difficulty": 1,
+        "slug": "bob",
+        "topics": [
+            "Strings",
+            "Control-flow (if-else statements)"
+        ]
+    },
+    {
+        "difficulty": 1,
+        "slug": "leap",
+        "topics": [
+            "Integers"
+        ]
+    },
+    {
+        "difficulty": 1,
+        "slug": "gigasecond",
+        "topics": [
+            "Dates"
+        ]
+    },
+    {
+        "difficulty": 1,
+        "slug": "difference-of-squares",
+        "topics": [
+            "Integers"
+        ]
+    },
+    {
+        "difficulty": 1,
+        "slug": "sum-of-multiples",
+        "topics": [
+            "Lists",
+            "Transforming"
+        ]
+    },
+    {
+        "difficulty": 1,
+        "slug": "space-age",
+        "topics": [
+            "Discriminated unions",
+            "Floating-point numbers"
+        ]
+    },
+    {
+        "difficulty": 2,
+        "slug": "hamming",
+        "topics": [
+            "Strings",
+            "Filtering"
+        ]
+    },
+    {
+        "difficulty": 2,
+        "slug": "nucleotide-count",
+        "topics": [
+            "Maps",
+            "Strings"
+        ]
+    },
+    {
+        "difficulty": 2,
+        "slug": "raindrops",
+        "topics": [
+            "Text formatting",
+            "Filtering"
+        ]
+    },
+    {
+        "difficulty": 2,
+        "slug": "grade-school",
+        "topics": [
+            "Maps",
+            "Sorting"
+        ]
+    },
+    {
+        "difficulty": 2,
+        "slug": "etl",
+        "topics": [
+            "Maps",
+            "Transforming"
+        ]
+    },
+    {
+        "difficulty": 3,
+        "slug": "clock",
+        "topics": [
+            "Time",
+            "Structural equality"
+        ]
+    },
+    {
+        "difficulty": 3,
+        "slug": "triangle",
+        "topics": [
+            "Integers",
+            "Discriminated unions"
+        ]
+    },
+    {
+        "difficulty": 3,
+        "slug": "robot-name",
+        "topics": [
+            "Randomness",
+            "Strings"
+        ]
+    },
+    {
+        "difficulty": 3,
+        "slug": "scrabble-score",
+        "topics": [
+            "Transforming"
+        ]
+    },
+    {
+        "difficulty": 3,
+        "slug": "phone-number",
+        "topics": [
+            "Parsing",
+            "Transforming"
+        ]
+    },
+    {
+        "difficulty": 3,
+        "slug": "perfect-numbers",
+        "topics": [
+            "Integers",
+            "Discriminated unions"
+        ]
+    },
+    {
+        "difficulty": 3,
+        "slug": "secret-handshake",
+        "topics": [
+            "Bitwise operations",
+            "Lists"
+        ]
+    },
+    {
+        "difficulty": 4,
+        "slug": "word-count",
+        "topics": [
+            "Strings",
+            "Maps",
+            "Transforming"
+        ]
+    },
+    {
+        "difficulty": 4,
+        "slug": "allergies",
+        "topics": [
+            "Enumerations",
+            "Bitwise operations",
+            "Filtering"
+        ]
+    },
+    {
+        "difficulty": 4,
+        "slug": "meetup",
+        "topics": [
+            "Dates"
+        ]
+    },
+    {
+        "difficulty": 4,
+        "slug": "anagram",
+        "topics": [
+            "Strings",
+            "Filtering"
+        ]
+    },
+    {
+        "difficulty": 4,
+        "slug": "acronym",
+        "topics": [
+            "Strings",
+            "Transforming"
+        ]
+    },
+    {
+        "difficulty": 4,
+        "slug": "all-your-base",
+        "topics": [
+            "Integers",
+            "Transforming"
+        ]
+    },
+    {
+        "difficulty": 4,
+        "slug": "largest-series-product",
+        "topics": [
+            "Strings",
+            "Integers",
+            "Transforming"
+        ]
+    },
+    {
+        "difficulty": 5,
+        "slug": "roman-numerals",
+        "topics": [
+            "Recursion",
+            "Transforming"
+        ]
+    },
+    {
+        "difficulty": 5,
+        "slug": "run-length-encoding",
+        "topics": [
+            "Algorithms",
+            "Transforming"
+        ]
+    }
   ],
   "deprecated": [
 

data/tracks/objective-c/exercises/largest-series-product/LargestSeriesProductExample.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+@interface LargestSeriesProduct : NSObject
+
+- (instancetype)initWithNumberString:(NSString *)numberString;
+- (long)largestProduct:(int)numberOfDigits;
+
+@end

data/tracks/objective-c/exercises/largest-series-product/LargestSeriesProductExample.m

@@ -0,0 +1,63 @@
+#import "LargestSeriesProductExample.h"
+
+@implementation LargestSeriesProduct {
+    NSArray<NSNumber *> *_numbers;
+}
+
+- (instancetype)initWithNumberString:(NSString *)numberString {
+    if (self = [super init]) {
+        NSMutableArray<NSNumber *> *numbers = [[NSMutableArray alloc] initWithCapacity:[numberString length]];
+        NSCharacterSet *decimalSet = [NSCharacterSet decimalDigitCharacterSet];
+        
+        for (int i = 0; i < [numberString length]; i++) {
+            unichar character = [numberString characterAtIndex:i];
+            if (![decimalSet characterIsMember:character]) {
+                @throw [NSException exceptionWithName:@"Invalid input" reason:@"Non-decimal character" userInfo:nil];
+            }
+            
+            NSString *digit = [NSString stringWithFormat:@"%c", character];
+            
+            [numbers addObject:[NSNumber numberWithInt:[digit intValue]]];
+        }
+        
+        _numbers = numbers;
+    }
+    
+    return self;
+}
+
+- (long)largestProduct:(int)numberOfDigits {
+    if (numberOfDigits < 0) {
+        @throw [NSException exceptionWithName:@"Invalid request" reason:@"Negative span" userInfo:nil];
+    }
+    
+    int endIndex = (int)[_numbers count] - numberOfDigits;
+    
+    if (endIndex < 0) {
+        @throw [NSException exceptionWithName:@"Invalid request" reason:@"Span longer than string length" userInfo:nil];
+    }
+    
+    long result = 0;
+    
+    for (int i = 0; i <= endIndex; i++) {
+        NSMutableArray *selectedNumbers = [[NSMutableArray alloc] init];
+        
+        for (int j = i; j < i + numberOfDigits; j++) {
+            [selectedNumbers addObject:_numbers[j]];
+        }
+        
+        long total = 1;
+        
+        for (NSNumber *selectedNumber in selectedNumbers) {
+            total *= [selectedNumber intValue];
+        }
+        
+        if (total > result) {
+            result = total;
+        }
+    }
+    
+    return result;
+}
+
+@end

data/tracks/objective-c/exercises/largest-series-product/LargestSeriesProductTest.m

@@ -0,0 +1,84 @@
+#import <XCTest/XCTest.h>
+
+#if __has_include("LargestSeriesProductExample.h")
+# import "LargestSeriesProductExample.h"
+# else
+# import "LargestSeriesProduct.h"
+#endif
+
+
+@interface LargestSeriesProductTest : XCTestCase
+
+@end
+
+@implementation LargestSeriesProductTest
+
+- (void)testCanFindTheLargestProductOf2WithNumbersInOrder {
+    XCTAssertEqual(72, [[[LargestSeriesProduct alloc] initWithNumberString:@"0123456789"] largestProduct:2]);
+}
+
+- (void)testCanFindTheLargestProductOf2 {
+    XCTAssertEqual(48, [[[LargestSeriesProduct alloc] initWithNumberString:@"576802143"] largestProduct:2]);
+}
+
+- (void)testFindsTheLargestProductIfSpanEqualsLength {
+    XCTAssertEqual(18, [[[LargestSeriesProduct alloc] initWithNumberString:@"29"] largestProduct:2]);
+}
+
+- (void)testCanFindTheLargestProductOf3WithNumbersInOrder {
+    XCTAssertEqual(504, [[[LargestSeriesProduct alloc] initWithNumberString:@"0123456789"] largestProduct:3]);
+}
+
+- (void)testCanFindTheLargestProductOf3 {
+    XCTAssertEqual(270, [[[LargestSeriesProduct alloc] initWithNumberString:@"1027839564"] largestProduct:3]);
+}
+
+- (void)testCanFindTheLargestProductOf5WithNumbersInOrder {
+    XCTAssertEqual(15120, [[[LargestSeriesProduct alloc] initWithNumberString:@"0123456789"] largestProduct:5]);
+}
+
+- (void)testCanGetTheLargestProductOfABigNumber {
+    XCTAssertEqual(23520, [[[LargestSeriesProduct alloc] initWithNumberString:@"73167176531330624919225119674426574742355349194934"] largestProduct:6]);
+}
+
+- (void)testCanGetTheLargestProductOfAnotherBigNumber {
+    XCTAssertEqual(28350, [[[LargestSeriesProduct alloc] initWithNumberString:@"52677741234314237566414902593461595376319419139427"]  largestProduct:6]);
+}
+
+- (void)testCanGetTheLargestProductOfABigNumberProjectEuler {
+    XCTAssertEqual(23514624000, [[[LargestSeriesProduct alloc] initWithNumberString:@"7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"] largestProduct:13]);
+}
+
+- (void)testReportsZeroIfTheOnlyDigitsAreZero {
+    XCTAssertEqual(0, [[[LargestSeriesProduct alloc] initWithNumberString:@"0000"] largestProduct:2]);
+}
+
+- (void)testReportsZeroIfAllSpansIncludeZero {
+    XCTAssertEqual(0, [[[LargestSeriesProduct alloc] initWithNumberString:@"99099"] largestProduct:3]);
+}
+
+- (void)testRejectsSpanLongerThanStringLength {
+    XCTAssertThrows([[[LargestSeriesProduct alloc] initWithNumberString:@"123"] largestProduct:4]);
+}
+
+- (void)testReports1ForEmptyStringAndEmptyProduct0Span {
+    XCTAssertEqual(1, [[[LargestSeriesProduct alloc] initWithNumberString:@""] largestProduct:0]);
+}
+
+- (void)testReports1ForNonemptyStringAndEmptyProduct0Span {
+    XCTAssertEqual(1, [[[LargestSeriesProduct alloc] initWithNumberString:@"123"] largestProduct:0]);
+}
+
+- (void)testRejectsEmptyStringAndNonzeroSpan {
+    XCTAssertThrows([[[LargestSeriesProduct alloc] initWithNumberString:@""] largestProduct:1]);
+}
+
+- (void)testRejectsInvalidCharacterInDigits {
+    XCTAssertThrows([[[LargestSeriesProduct alloc] initWithNumberString:@"1234a5"] largestProduct:2]);
+}
+
+- (void)testRejectsNegativeSpan {
+    XCTAssertThrows([[[LargestSeriesProduct alloc] initWithNumberString:@"12345"] largestProduct:-1]);
+}
+
+@end