trackler 2.2.1.25 → 2.2.1.26

data/tracks/elixir/exercises/protein-translation/README.md

@@ -10,9 +10,9 @@ Codons: `"AUG", "UUU", "UCU"`
 => which become a polypeptide with the following sequence =>
 
 Protein: `"Methionine", "Phenylalanine", "Serine"`
- 
+
 There are 64 codons which in turn correspond to 20 amino acids; however, all of the codon sequences and resulting amino acids are not important in this exercise.  If it works for one codon, the program should work for all of them.
-However, feel free to expand the list in the test suite to include them all.  
+However, feel free to expand the list in the test suite to include them all.
 
 There are also four terminating codons (also known as 'STOP' codons); if any of these codons are encountered (by the ribosome), all translation ends and the protein is terminated.
 
@@ -20,7 +20,7 @@ All subsequent codons after are ignored, like this:
 
 RNA: `"AUGUUUUCUUAAAUG"` =>
 
-Codons: `"AUG", "UUU", "UCU", "UAG", "AUG"` => 
+Codons: `"AUG", "UUU", "UCU", "UAA", "AUG"` =>
 
 Protein: `"Methionine", "Phenylalanine", "Serine"`
 
@@ -39,7 +39,6 @@ UGU, UGC              | Cysteine
 UGG                   | Tryptophan
 UAA, UAG, UGA         | STOP
 
-
 Learn more about [protein translation on Wikipedia](http://en.wikipedia.org/wiki/Translation_(biology))
 
 ## Running tests
@@ -83,4 +82,5 @@ see the [help page](http://exercism.io/languages/elixir).
 Tyler Long
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/go/exercises/phone-number/.meta/description.md

@@ -0,0 +1,34 @@
+Clean up user-entered phone numbers so that they can be sent SMS messages.
+
+The **North American Numbering Plan (NANP)** is a telephone numbering system used by many countries in North America like the United States, Canada or Bermuda. All NANP-countries share the same international country code: `1`.
+
+NANP numbers are ten-digit numbers consisting of a three-digit Numbering Plan Area code, commonly known as *area code*, followed by a seven-digit local number. The first three digits of the local number represent the *exchange code*, followed by the unique four-digit number which is the *subscriber number*.
+
+
+The format is usually represented as
+```
+(NXX)-NXX-XXXX
+```
+where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.
+
+Your task is to clean up differently formated telephone numbers by removing punctuation and the country code (1) if present.
+
+For example, the inputs
+- `+1 (613)-995-0253`
+- `613-995-0253`
+- `1 613 995 0253`
+- `613.995.0253`
+
+should all produce the output below from a Number() function.
+
+`6139950253`
+
+Additionally, a Format() function should produce the output
+
+`(613) 995-0253`
+
+and an AreaCode() function should output
+
+`613`
+
+**Note:** As this exercise only deals with telephone numbers used in NANP-countries, only 1 is considered a valid country code.

data/tracks/go/exercises/phone-number/.meta/metadata.yml

@@ -0,0 +1,4 @@
+---
+blurb: "Clean up user-entered phone numbers so that they can be sent SMS messages."
+source: "Event Manager by JumpstartLab"
+source_url: "http://tutorials.jumpstartlab.com/projects/eventmanager.html"

data/tracks/go/exercises/phone-number/README.md

@@ -21,10 +21,18 @@ For example, the inputs
 - `1 613 995 0253`
 - `613.995.0253`
 
-should all produce the output
+should all produce the output below from a Number() function.
 
 `6139950253`
 
+Additionally, a Format() function should produce the output
+
+`(613) 995-0253`
+
+and an AreaCode() function should output
+
+`613`
+
 **Note:** As this exercise only deals with telephone numbers used in NANP-countries, only 1 is considered a valid country code.
 
 ## Running the tests

data/tracks/javascript/.gitignore

@@ -6,3 +6,5 @@ tmp
 bin/configlet
 bin/configlet.exe
 .idea
+
+*.js~

data/tracks/javascript/README.md

@@ -1,4 +1,4 @@
-# xJavaScript [![Build Status](https://travis-ci.org/exercism/xjavascript.svg?branch=master)](https://travis-ci.org/exercism/xjavascript)
+# JavaScript [![Build Status](https://travis-ci.org/exercism/javascript.svg?branch=master)](https://travis-ci.org/exercism/javascript)
 
 Exercism exercises in JavaScript
 
@@ -8,7 +8,7 @@ To run the tests, you'll need NodeJS and Jasmine. For information about how to i
 
 ## Running Unit Test Suite
 
-The following commands assume that you are in the 'xjavascript' directory:
+The following commands assume that you are in the 'javascript' directory:
 
 ### All Assignments
 

data/tracks/javascript/config.json

@@ -1029,6 +1029,19 @@
       "unlocked_by": "linked-list",
       "uuid": "c21ab6e8-b845-49d0-a2f6-1c89c7a07626"
     },
+    {
+      "core" :  false,
+      "difficulty" : 8,
+      "slug" : "change",
+       "topics": [
+          "Algorithms",
+          "Mathematics",
+          "Performance",
+          "Searching"
+      ],
+      "unlocked_by": "prime-factors",
+      "uuid" : "910fe904-7e3c-11e7-bb31-be2e44b06b34"
+    },
     {
       "deprecated": true,
       "slug": "nucleotide-count",
@@ -1043,4 +1056,4 @@
   "foregone": [],
   "language": "JavaScript",
   "test_pattern": ".*[.]spec[.]js$"
-}
+}

data/tracks/javascript/exercises/change/README.md

@@ -0,0 +1,36 @@
+# Change
+
+Correctly determine the change to be given using the least number of coins.
+
+The solution will need to accept a value of change to be given and an array of
+coin denominations.   The program returns the array of coin denominations to
+produce the correct amount of change.  For example, if change for 37 cents  
+is required from coins with the denominations of 1, 5, 10 and 25 then the
+result is an array with the values: 1, 1, 10 and 25.
+
+## Setup
+
+Go through the setup instructions for JavaScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/javascript
+
+## Making the Test Suite Pass
+
+Execute the tests with:
+
+    jasmine <exercise-name>.spec.js
+
+Replace `<exercise-name>` with the name of the current exercise. E.g., to
+test the Hello World exercise:
+
+    jasmine hello-world.spec.js
+
+In many test suites all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+changing `xit` to `it`.
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/javascript/exercises/change/change.spec.js

@@ -0,0 +1,73 @@
+
+
+
+var  Change =require('./change');
+
+describe('Change', function() {
+
+  it('change for 1 cent',function() {
+     var change= new Change();
+     var result = change.calculate([1,5, 10, 25],1);
+     expect(result).toEqual([1]);
+  });
+
+  xit('return a single coin',function() {
+    var change= new Change();
+    var result = change.calculate([1,5, 10, 25, 100],25);
+    expect(result).toEqual([25]);
+  });
+
+  xit('multiple coins coin',function() {
+    var change= new Change();
+    var result = change.calculate([1,5, 10, 25, 100],15);
+    expect(result).toEqual([5, 10]);
+  });
+
+  xit('test with Lillipution Currency where a greedy algorithm fails',function() {
+    // https://en.wikipedia.org/wiki/Change-making_problem#Greedy_method
+     var change= new Change();
+     var result = change.calculate([1, 4, 15, 20, 50],23);
+     expect(result).toEqual([4,4,15]);
+  });
+
+  xit('test with lower Elbonian Currency where a greedy algorithm fails',function() {
+    // https://en.wikipedia.org/wiki/Change-making_problem#Greedy_method
+    var change= new Change();
+    var result = change.calculate([1, 5, 10, 21, 25],63);
+    expect(result).toEqual([21, 21, 21]);
+  });
+
+  xit('test large amount of change',function() {
+    var change= new Change();
+    var result = change.calculate([1, 2, 5, 10, 20, 50 , 100], 999);
+    expect(result).toEqual([2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100]);
+  });
+
+  xit('test zero change',function() {
+    var change= new Change();
+    var result = change.calculate([1, 5, 10, 21, 25], 0);
+    expect(result).toEqual([]);
+  });
+
+  xit('test less than the smallest currency represented',function() {
+    var change= new Change();
+    var message = 'The total 3 cannot be represented in the given currency.';
+    var test=function(){return change.calculate([5,10],3);};
+    expect(test).toThrowError(Error,message);
+  });
+
+  xit('test a large value that the currency cannot represent',function() {
+    var change= new Change();
+    var message ='The total 94 cannot be represented in the given currency.';
+    var test=function(){return change.calculate([5,10], 94);};
+    expect(test).toThrowError(Error,message);
+  });
+
+  xit('negative change is rejected',function() {
+    var change= new Change();
+    var message = 'Negative totals are not allowed.';
+    var test = function(){return change.calculate([1,2,5],-5);};
+    expect(test).toThrowError(Error, message);
+  });
+    
+});

data/tracks/javascript/exercises/change/example.js

@@ -0,0 +1,204 @@
+"use strict"
+
+
+var Change = function()
+{
+
+
+}
+
+module.exports=Change;
+
+
+//data structure to hold each candidate solution that is generated
+var Candidate = function()
+{
+    
+    var searched=false;
+    var coins=[];
+
+    this.Searched =function()
+    {
+        searched=true;
+    }
+    
+    this.isSearched = function()
+    {
+        return searched;
+    }
+    
+    this.getCoins = function()
+    {
+        return coins;
+    }
+    
+    this.addCoin = function(coin)
+    {
+        function sortNum(a,b)
+        {
+            return a-b;
+        }
+        
+        coins.push(coin);
+        coins.sort(sortNum);
+
+    }
+    
+    this.getCoinCount=function()
+    {
+        return coins.length;
+    }
+
+    this.getSum=function()
+    {
+        function getSum(total, num){return total+num;}
+        return coins.reduce(getSum);
+    }
+  
+
+}
+
+Change.prototype.calculate=function(coinArray, target)
+{
+
+    var candidates=[];
+    //fill the array with 0 to start
+    candidates[target]=0;
+    candidates.fill(0);
+
+    //validation checks up front
+    if(target==0)return [];
+
+    if(target<0)
+    {
+        throw new Error( 'Negative totals are not allowed.');
+    }
+
+    if(target<Math.min.apply(null,coinArray))
+    {
+        throw new Error('The total '+ target +' cannot be represented in the given currency.');
+    }
+
+    
+    initialize();
+    //printAll();
+   
+
+    //process the arrange until everything is searched
+    while(isDone()==false)
+    {
+        let candidate=getNext();
+        branch(candidate);
+        candidate.Searched();
+    }
+     //printAll();
+
+
+    //print the result
+    if(typeof(candidates[target])!='number')
+        return candidates[target].getCoins();
+    else throw new Error('The total '+ target +' cannot be represented in the given currency.');
+
+
+    //print the candidate array
+    function printAll()
+    {
+        for(let j=0; j< candidates.length; j++)
+        {
+            if(typeof(candidates[j])=='object')
+            {
+                console.log('index: ' + j + ' ' + candidates[j].getCoins() + ' searched: ' + candidates[j].isSearched());
+            }
+            else
+            {
+                console.log('index: ' + j + ' is empty ' + typeof(candidates[j]));
+            }
+        }
+    }
+
+    //initialize the candidate array with the given coins only
+    function initialize()
+    {
+        for(let j=0; j<coinArray.length; j++)
+        {
+            let temp= coinArray[j];
+            let candidate = new Candidate();
+            candidate.addCoin(temp);
+            saveCandidate(candidate);
+            
+        }
+    }
+
+    //is everthing searched?
+    function isDone()
+    {
+        let done=true;
+        for (let i=0; i<candidates.length; i++)
+        {
+            let temp=candidates[i];
+            if(typeof(temp)!='number')
+            {
+                if(temp.isSearched()==false)
+                {
+                    done=false;
+                    break;
+                }
+            }
+        }
+        return done;
+    }
+    
+    //get the next unsearched member of the candidate array
+    function getNext()
+    {
+        for(let i=0; i< candidates.length; i++)
+        {
+            let temp= candidates[i];
+            if (typeof(temp)!='number' && 
+                temp.isSearched()==false)return temp;
+        }
+        return null;
+
+    }
+
+    //save a new candidate to the candidate array
+    function saveCandidate(candidate)
+    {
+        let sum=candidate.getSum();
+
+        if( candidate.getSum()<=target &&
+            typeof(candidates[sum])!='number' &&
+            candidates[sum].getCoinCount()>candidate.getCoinCount())
+        {
+            candidates[sum]=candidate;
+        }
+
+        if(candidate.getSum()<=target &&
+           typeof(candidates[sum])=='number')
+        {
+            candidates[sum]=candidate;
+        }
+    }
+    
+
+    //for the candidate, generate another candate for each of the possible coins
+    function branch(current)
+    {
+        for(let j=0; j<coinArray.length; j++)
+        {
+            
+            //make a new Candidate for coin type
+            let candidate= new Candidate();
+
+            //copy the curent coins into it and add the new coin type
+            for(var i=0; i< current.getCoins().length; i++)candidate.addCoin(current.getCoins()[i]);
+
+            candidate.addCoin(coinArray[j]);
+
+            saveCandidate(candidate);
+        }
+        
+    }
+
+}
+