Merge branch 'stuntguy3000-pig-latin'

Adding pig Latin converter to repository.
PR made for hacktoberfest2020

Author: tejas-2232

Pig_latin_6/pig_latin.js

@@ -0,0 +1,31 @@
+function pigLatin_declarative(str) {
+    return str
+        .replace(/^([aeiouy])(._)/, '$1$2way')
+        .replace(/^(_[_^aeiouy]+)(._)/, '$2$1ay')
+}
+
+function pigLatin_imperative(str) {
+    // Convert string to lowercase
+    str = str.toLowerCase()
+    // Initialize array of vowels
+    const vowels = ["a", "e", "i", "o", "u"];
+    // Initialize vowel index to 0
+    let vowelIndex = 0;
+
+    if (vowels.includes(str[0])) {
+        // If first letter is a vowel
+        return str + "way";
+    } else {
+        // If the first letter isn't a vowel i.e is a consonant
+        for (let char of str) {
+            // Loop through until the first vowel is found
+            if (vowels.includes(char)) {
+                // Store the index at which the first vowel exists
+                vowelIndex = str.indexOf(char);
+                break;
+            }
+        }
+        // Compose final string
+        return str.slice(vowelIndex) + str.slice(0, vowelIndex) + "ay";
+    }
+}

README.md

@@ -447,15 +447,116 @@ method tests whether all elements pass the test or not which is implemented by p
 <hr>
 <hr>
 
-<b>6. Name </b>
+<b>6. Pig Latin Translator</b>
 
-__The challenge:__ <p> </p>
+For specific information on Pig Latin, view this [article](https://en.wikipedia.org/wiki/Pig_Latin).
 
+__The challenge:__ <p>Convert a string of text into Pig Latin.</p>
 
-__Algorithmic Thinking:__ <p> </p>
 
+__Algorithmic Thinking:__
+
+We will consider two(2) ways to implement this function in JavaScript. They are:
+
+An imperative approach
+A declarative approach
+Before going ahead to implement both solutions, it’d be helpful to gain a better understanding of the two terms used above.
+
+Imperative vs Declarative
+Very often, we find these terms thrown around like they are very simple concepts everyone should know. However, the difference is usually not much obvious to most.
+
+Simply put, an imperative style of programming is one which specifies how things get done. Although this might sound like what you do each time you write code, there's a difference to it. Imagine you were to add an array of numbers and return the sum, there are different ways you could approach the problem. One way could be writing a forloop that'd go over each element in the array and cumulatively add every element to an accumulator until the final sum is reached. That is imperative. You are specifying how things get done.
+
+On the other hand, a declarative approach would abstract this process, allowing you to specify what should be done rather than how. Thus, you may use the .reduce() method on the array to reduce every element to a final value by returning the sum within the call back.
+
+[Source](https://scotch.io/courses/the-ultimate-guide-to-javascript-algorithms/pig-latin)
+
+__code Implementation:__ 
+
+1. Imperative Approach
+
+We start by converting the received string str to lowercase. This is to prevent any casing related errors during comparison(“a” does not equal “A”).
+
+```js
+    // Convert string to lowercase
+    str = str.toLowerCase()
+```
+
+Next, we initialize two variables:
+
+```js
+    // Initialize array of vowels
+    const vowels = ["a", "e", "i", "o", "u"];
+    // Initialize vowel index to 0
+    let vowelIndex = 0;
+```
+
+vowels - containing the five English vowels
+vowelIndex - for storing the index at which the first vowel in the word is found. It is initialized to 0.
+
+We use an if…else statement to check if the first letter of the word can be found within our vowels array by calling the .includes() method on the array while passing it the first letter of the string str[0]. If it is found, this returns true, which implies that the first letter is a vowel. Hence, we simply add "``way``" to the end of the string and return the result as the Pig Latin equivalent.
+
+
+```js
+    if (vowels.includes(str[0])) {
+        // If first letter is a vowel
+        return str + "way";
+    } else {
+        ...
+    }
+```
+
+If the statement evaluates to false, it signifies that the starting character is a consonant. Hence, we use a for…of loop to iterate through the string to identify the position of the first vowel. When we locate the first vowel, we use the .indexOf() method to retrieve it’s position in the string and store it into the variable vowelIndex. After this step we terminate the loop using the break statement.
+
+```js
+    // If the first letter isn't a vowel i.e is a consonant
+        for (let char of str) {
+            // Loop through until the first vowel is found
+            if (vowels.includes(char)) {
+                // Store the index at which the first vowel exists
+                vowelIndex = str.indexOf(char);
+                break;
+            }
+        }
+```
+
+At the last line, we use the .slice() method to manipulate the string to generate the Pig Latin equivalent.
+
+```js
+    return str.slice(vowelIndex) + str.slice(0, vowelIndex) + "ay";
+```
+
+2. Declarative Approach
+
+In this approach, we implement a very concise solution to this challenge by combining the .replace() method and regular expressions to transform the received string into its Pig Latin equivalent.
+
+
+Our solution comprises mainly of two parts as analyzed below:
+
+```js
+ str.replace(/^([aeiouy])(._)/, '$1$2way')
+```
+
+The first .replace statement specifies a replacement to be carried out if the word begins with a vowel. This is specified in the first bracket within the_ *.replace()* method call i.e *([aeiou])*. The second bracket *(.*)* refers to every other character after the vowel. Thus, the expression specifies a pattern for words beginning with a vowel and followed by anything else. When this case is matched, a new string in the format of '``$1$2way``' is generated and used to replace the original srtring. $1 here refers to the first bracket and $2, the second bracket. This means that we simply take the word as it was and affix "``way``" to the end.
+
+```js
+ str.replace(/^(_[_^aeiouy]+)(._)/, '$2$1ay')
+```
+
+The second .replace statement specifies that if the word does not start with a vowel i.e ^([aeiouy]+), and is followed by anything else (``*.*)*, it should be replaced with a string formatted in the order '$2$1ay``'. The plus sign in ^([aeiouy]+) caters for a situation where there is a consonant cluster. Thus it represents every non-vowel character at the start of the word. '$2$1ay' generates the new string in the order of remaining characters + consonant cluster + '``ay``'. This gives the Pig Latin equivalent.
+
+```js
+function pigLatin_declarative(str) {
+    return str
+        .replace(/^([aeiouy])(._)/, '$1$2way')
+        .replace(/^(_[_^aeiouy]+)(._)/, '$2$1ay')
+}
+```
+
+Note that we chain both .replace() methods in succession such that both cases are tested and only the one that matches will be evaluated further.
+
+[Source](https://scotch.io/courses/the-ultimate-guide-to-javascript-algorithms/pig-latin)
 
-__code Implementation:__ <p> </p>
 
 <hr>
 <hr>