├── Hard
    ├── PentagonalNumber.py
    ├── PentagonalNumber.js
    ├── PentagonalNumber.c
    ├── KaprekarsConstant.js
    ├── KaprekarsConstant.c
    └── MaximalSquare.js
├── Easy
    ├── CheckNums.js
    ├── AlphabetSoup.js
    ├── TimeConvert.js
    ├── FirstReverse.js
    ├── SimpleAdding.js
    ├── SimpleAdding.c
    ├── TimeConvert.c
    ├── CheckNums.c
    ├── LetterCapitalize.js
    ├── FirstFactorial.c
    ├── FirstReverse.c
    ├── FirstFactorial.js
    ├── LongestWord.js
    ├── AlphabetSoup.c
    ├── LetterCapitalize.c
    ├── SimpleSymbols.js
    ├── LetterChanges.js
    ├── SimpleSymbols.c
    ├── LetterChanges.c
    ├── LongestWord.c
    ├── VowelSquare.js
    ├── QuestionMarks.c
    ├── VowelSquare.c
    ├── QuestionMarks.js
    └── CorrectPath.js
├── .gitignore
└── README.md


/Hard/PentagonalNumber.py:
--------------------------------------------------------------------------------
1 | def PentagonalNumber(n):
2 | 	return 1+5*(n*(n-1)/2)
3 | 
4 | print PentagonalNumber(raw_input())	
5 | 


--------------------------------------------------------------------------------
/Easy/CheckNums.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function CheckNums(num1,num2) take both parameters being passed and return the string true if num2 is greater than num1, otherwise return the string false. If the parameter values are equal to each other then return the string -1.
 4 | */
 5 | function CheckNums(num1,num2) {
 6 |   return (num1 == num2)?-1:(num2>num1)
 7 | }
 8 | 
 9 | // keep this function call here
10 | CheckNums(readline());
11 | 


--------------------------------------------------------------------------------
/Easy/AlphabetSoup.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function AlphabetSoup(str) take the str string parameter being passed and return the string with the letters in alphabetical order (ie. hello becomes ehllo). Assume numbers and punctuation symbols will not be included in the string.
 4 | */
 5 | function AlphabetSoup(str) {
 6 |   return str.split("").sort().join("");
 7 | }
 8 | 
 9 | // keep this function call here
10 | AlphabetSoup(readline());
11 | 


--------------------------------------------------------------------------------
/Easy/TimeConvert.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function TimeConvert(num) take the num parameter being passed and return the number of hours and minutes the parameter converts to (ie. if num = 63 then the output should be 1:3). Separate the number of hours and minutes with a colon.
 4 | */
 5 | 
 6 | function TimeConvert(num) {
 7 |   return parseInt(num/60)+":"+num%60;
 8 | }
 9 | 
10 | // keep this function call here
11 | TimeConvert(readline());
12 | 


--------------------------------------------------------------------------------
/Easy/FirstReverse.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function FirstReverse(str) take the str parameter being passed and return the string in reversed order. For example: if the input string is "Hello World and Coders" then your program should return the string "sredoC dna dlroW olleH". 
 4 | */
 5 | 
 6 | function FirstReverse(str) {
 7 | 	return str.split("").reverse().join("");
 8 | }
 9 | 
10 | // keep this function call here
11 | FirstReverse(readline());
12 | 


--------------------------------------------------------------------------------
/Easy/SimpleAdding.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function SimpleAdding(num) add up all the numbers from 1 to num. For example: if the input is 4 then your program should return 10 because 1 + 2 + 3 + 4 = 10. For the test cases, the parameter num will be any number from 1 to 1000. 
 4 | */
 5 | 
 6 | function SimpleAdding(num) {
 7 |     return parseInt(num*(num+1)/2); //in case of floating point
 8 | }
 9 | 
10 | // keep this function call here
11 | SimpleAdding(readline());
12 | 


--------------------------------------------------------------------------------
/Easy/SimpleAdding.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function SimpleAdding(num) add up all the numbers from 1 to num. For example: if the input is 4 then your program should return 10 because 1 + 2 + 3 + 4 = 10. For the test cases, the parameter num will be any number from 1 to 1000.
 4 | */
 5 | #include <stdio.h>
 6 | 
 7 | void SimpleAdding(int num) {
 8 |     printf("%d", num*(num+1)/2);
 9 | }
10 | 
11 | int main(void) {
12 |     SimpleAdding(gets(stdin));
13 |     return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/Easy/TimeConvert.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function TimeConvert(num) take the num parameter being passed and return the number of hours and minutes the parameter converts to (ie. if num = 63 then the output should be 1:3). Separate the number of hours and minutes with a colon.
 4 | */
 5 | #include <stdio.h>
 6 | 
 7 | void TimeConvert(int num){
 8 |     printf("%d:%d",num/60,num%60);
 9 | }
10 | 
11 | int main(void) {
12 |     TimeConvert(gets(stdin));
13 |     return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/Easy/CheckNums.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function CheckNums(num1,num2) take both parameters being passed and return the string true if num2 is greater than num1, otherwise return the string false. If the parameter values are equal to each other then return the string -1.
 4 | */
 5 | #include <stdio.h>
 6 | 
 7 | void CheckNums(num1,num2) {
 8 | 	printf("%s", (num1 == num2)?"-1":((num2>num1)?"true":"false") );
 9 | }
10 | 
11 | int main(void) {
12 |     CheckNums(gets(stdin));
13 |     return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/Easy/LetterCapitalize.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESITON:
 3 | Have the function LetterCapitalize(str) take the str parameter being passed and capitalize the first letter of each word. Words will be separated by only one space. 
 4 | */
 5 | 
 6 | function LetterCapitalize(str) {
 7 |     var s = str.split(" ");
 8 |     for(var i=0;i<s.length;i++){
 9 |         var w = s[i].split("");
10 |         w[0] = w[0].toUpperCase();
11 |         s[i] = w.join("");
12 |     }
13 | 
14 |     return s.join(" ");
15 | }
16 | 
17 | // keep this function call here
18 | LetterCapitalize(readline());
19 | 


--------------------------------------------------------------------------------
/Easy/FirstFactorial.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function FirstFactorial(num) take the num parameter being passed and return the factorial of it. For example: if num = 4, then your program should return (4 * 3 * 2 * 1) = 24. For the test cases, the range will be between 1 and 18 and the input will always be an integer.
 4 | */
 5 | 
 6 | #include <stdio.h>
 7 | 
 8 | int FirstFactorial(int n) {
 9 |     if(n<=2) return n;
10 |     return n*FirstFactorial(n-1);
11 | }
12 | 
13 | int main(void) {
14 | 	int f = FirstFactorial(gets(stdin));
15 | 	printf("%d",f);
16 | 	return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/Easy/FirstReverse.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function FirstReverse(str) take the str parameter being passed and return the string in reversed order. For example: if the input string is "Hello World and Coders" then your program should return the string "sredoC dna dlroW olleH".
 4 | */
 5 | 
 6 | #include <stdio.h>
 7 | #include <string.h>
 8 | 
 9 | void FirstReverse(char * str) {
10 |     int N = strlen(str);
11 |     for(int i=0;i<N;i++){
12 |         printf("%c", str[N-i-1]);
13 |     }
14 | }
15 | 
16 | int main(void) {
17 |     FirstReverse(gets(stdin));
18 |     return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/Easy/FirstFactorial.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function FirstFactorial(num) take the num parameter being passed and return the factorial of it. For example: if num = 4, then your program should return (4 * 3 * 2 * 1) = 24. For the test cases, the range will be between 1 and 18 and the input will always be an integer. 
 4 | */
 5 | 
 6 | var fact = {}
 7 | 
 8 | function FirstFactorial(n) {
 9 |     if(n<=2) return n;
10 |     if(fact.hasOwnProperty(n)) return fact[n]
11 | 
12 |     return fact[n] = n*FirstFactorial(n-1);
13 | }
14 | 
15 | // keep this function call here
16 | FirstFactorial(readline());
17 | 


--------------------------------------------------------------------------------
/Hard/PentagonalNumber.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function PentagonalNumber(num) read num which will be a positive integer and determine how many dots exist in a pentagonal shape around a center dot on the Nth iteration. For example, in the image below you can see that on the first iteration there is only a single dot, on the second iteration there are 6 dots, on the third there are 16 dots, and on the fourth there are 31 dots.
 4 | */
 5 | 
 6 | function PentagonalNumber(n) {
 7 | 	//Basically: f(n) = 1+5*(1+2+...+n-1) = 1+5*(n+1-1)(n-1)/2 (based on Gauss summation)
 8 | 	return 1+5*parseInt(n*(n-1)/2);
 9 | }
10 | 
11 | // keep this function call here
12 | PentagonalNumber(readline());
13 | 


--------------------------------------------------------------------------------
/Hard/PentagonalNumber.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function PentagonalNumber(num) read num which will be a positive integer and determine how many dots exist in a pentagonal shape around a center dot on the Nth iteration. For example, in the image below you can see that on the first iteration there is only a single dot, on the second iteration there are 6 dots, on the third there are 16 dots, and on the fourth there are 31 dots.
 4 | */
 5 | #include <stdio.h>
 6 | 
 7 | int PentagonalNumber(int n) {
 8 | 	//Basically: f(n) = 1+5*(1+2+...+n-1) = 1+5*(n+1-1)(n-1)/2 (based on Gauss summation)
 9 | 	return 1+5*(n*(n-1)/2);
10 | }
11 | 
12 | int main(void){
13 | 	printf("%d", PentagonalNumber(gets(stdin)));
14 | }
15 | 


--------------------------------------------------------------------------------
/Easy/LongestWord.js:
--------------------------------------------------------------------------------
 1 | /* QUESTION: 
 2 | Have the function LongestWord(sen) take the sen parameter being passed and return the largest word in the string. If there are two or more words that are the same length, return the first word from the string with that length. Ignore punctuation and assume sen will not be empty.
 3 | */
 4 | 
 5 | function LongestWord(sen) {
 6 |     var words = sen.replace(/[^a-zA-Z0-9 ]/gi,"").split(" ");
 7 | 
 8 |     var maxi = {
 9 |         "word":null,
10 |         "length":0
11 |     }
12 |     for(var i=0;i<words.length;i++){
13 |         if(words[i].length>maxi.length){
14 |             maxi.word = words[i];
15 |             maxi.length = words[i].length;
16 |         }
17 |     }
18 |     // code goes here
19 |     return maxi.word;
20 | }
21 | 
22 | // keep this function call here
23 | LongestWord(readline());
24 | 


--------------------------------------------------------------------------------
/Easy/AlphabetSoup.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function AlphabetSoup(str) take the str string parameter being passed and return the string with the letters in alphabetical order (ie. hello becomes ehllo). Assume numbers and punctuation symbols will not be included in the string.
 4 | */
 5 | #include<cstdio>
 6 | #include<cstring>
 7 | 
 8 | void AlphabetSoup(char * str){
 9 |     int N = strlen(str);
10 |     int i, j, count[26]; //for all 26 letters in the alphabet
11 |     for(i=0;i<=26;i++) count[i] = 0; //set all counts to 0 first
12 | 
13 |     for(i=0;i<N;i++){
14 |         int c = str[i]-'a'; //each character is actually an ASCII value
15 |         if(c>=0 && c<26){
16 |             count[c]++;
17 |         }
18 |     }
19 | 
20 |     for(i=0;i<26;i++)
21 |         for(j=0;j<count[i];j++)
22 |             printf("%c",(char)(i+'a'));
23 | }
24 | 
25 | int main(void) {
26 | 	AlphabetSoup(gets(stdin));
27 | 	return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/Easy/LetterCapitalize.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESITON:
 3 | Have the function LetterCapitalize(str) take the str parameter being passed and capitalize the first letter of each word. Words will be separated by only one space.
 4 | */
 5 | 
 6 | #include <stdio.h>
 7 | #include <string.h>
 8 | 
 9 | char toUpper(char c){
10 |     int n = c-'a';
11 |     char * upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
12 |     if(n>=0 && n<=26){ //lower case alpha letter
13 |         //printf("%c",upper[n]);
14 |         return upper[n];
15 |     }
16 |     return c;
17 | }
18 | 
19 | void LetterCapitalize(char * str){
20 |     short prevWasSpace = 1;
21 |     int i;
22 |     char c;
23 | 
24 |     for(i=0;i<strlen(str);i++){
25 |         c = (prevWasSpace)?toUpper(str[i]):str[i];
26 |         printf("%c",c);
27 |         prevWasSpace = (c==' ')?1:0;
28 |     }
29 | 
30 |     //printf("%s", str);
31 | }
32 | 
33 | int main(void) {
34 |     LetterCapitalize(gets(stdin));
35 |     return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/Easy/SimpleSymbols.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION: Have the function SimpleSymbols(str) take the str parameter being passed and determine if it is an acceptable sequence by either returning the string true or false. The str parameter will be composed of + and = symbols with several letters between them (ie. ++d+===+c++==a) and for the string to be true each letter must be surrounded by a + symbol. So the string to the left would be false. The string will not be empty and will have at least one letter. 
 3 | */
 4 | 
 5 | function SimpleSymbols(str) {
 6 |     var abc = new RegExp("[A-Z]","gi");
 7 | 
 8 |     var indexes = [];
 9 |     var result;
10 | 
11 |     while(result = abc.exec(str)){
12 |       indexes.push(result.index);
13 |     }
14 | 
15 |     for(i=0;i<indexes.length;i++){
16 |         if(indexes[i]===0 || indexes[i]==str.length-1) return false;
17 | 
18 |         var ind = indexes[i];
19 |         if(str[ind-1]!="+" || str[ind+1]!="+") return false;
20 |     }
21 | 
22 |     return true;
23 | }
24 | 
25 | // keep this function call here
26 | SimpleSymbols(readline());
27 | 


--------------------------------------------------------------------------------
/Easy/LetterChanges.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION: 
 3 | Have the function LetterChanges(str) take the str parameter being passed and modify it using the following algorithm. Replace every letter in the string with the letter following it in the alphabet (ie. c becomes d, z becomes a). Then capitalize every vowel in this new string (a, e, i, o, u) and finally return this modified string.
 4 | */
 5 | 
 6 | function LetterChanges(str) {
 7 |     var abc = "abcdefghijklmnopqrstuvwxyz";
 8 |     var rot1 = {"z":"a"};
 9 |     var l,i;
10 |     var vowels = {
11 |         "a":"A",
12 |         "e":"E",
13 |         "i":"I",
14 |         "o":"O",
15 |         "u":"U"
16 |     }
17 | 
18 |     for(i=0;i<abc.length-1;i++){ //avoid z
19 |         l = abc[i+1];
20 |         rot1[abc[i]] = (vowels.hasOwnProperty(l))?vowels[l]:l;
21 |     }
22 | 
23 |     _str = str.split("");
24 |     for(i=0;i<_str.length;i++){
25 |         l = _str[i];
26 |         _str[i] = (rot1.hasOwnProperty(l))?rot1[l]:l;
27 |     }
28 | 
29 |     // code goes here
30 |     return _str.join("");
31 | }
32 | 
33 | // keep this function call here
34 | LetterChanges(readline());
35 | 


--------------------------------------------------------------------------------
/Easy/SimpleSymbols.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION: Have the function SimpleSymbols(str) take the str parameter being passed and determine if it is an acceptable sequence by either returning the string true or false. The str parameter will be composed of + and = symbols with several letters between them (ie. ++d+===+c++==a) and for the string to be true each letter must be surrounded by a + symbol. So the string to the left would be false. The string will not be empty and will have at least one letter.
 3 | */
 4 | #include <stdio.h>
 5 | #include <string.h>
 6 | 
 7 | /*
 8 | Take note that for some reason, C does NOT have boolean types.
 9 | So we use unsigned char (with 0 and 1) instead.
10 | Unsigned char only has one byte.
11 | */
12 | unsigned char isLetter(char c){
13 |     //Lower case letter
14 |     int n = c-'a';
15 |     if(n>=0 && n<=26) return 1;
16 | 
17 |     //Upper case letter
18 |     n = c-'A';
19 |     if(n>=0 && n<=26) return 1;
20 | 
21 |     return 0;
22 | }
23 | 
24 | void SimpleSymbols(char * str){
25 |     int i, n = strlen(str);
26 |     char c;
27 | 
28 |     for(i=0;i<n;i++){
29 |         c = str[i];
30 | 
31 |         if(isLetter(c)) if(i==0 || i==n || str[i-1]!='+' || str[i+1]!='+'){
32 |             printf("false");
33 |             return;
34 |         }
35 |     }
36 | 
37 |     printf("true");
38 | }
39 | 
40 | int main(void) {
41 |     SimpleSymbols(gets(stdin));
42 |     return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/Easy/LetterChanges.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function LetterChanges(str) take the str parameter being passed and modify it using the following algorithm. Replace every letter in the string with the letter following it in the alphabet (ie. c becomes d, z becomes a). Then capitalize every vowel in this new string (a, e, i, o, u) and finally return this modified string.
 4 | */
 5 | 
 6 | #include <stdio.h>
 7 | #include <string.h>
 8 | 
 9 | /*
10 | Take note that for some reason, C does NOT have boolean types.
11 | So we use unsigned char (with 0 and 1) instead.
12 | Unsigned char only has one byte.
13 | */
14 | 
15 | /* Shift letters by 1 */
16 | char shift_letter(char c){
17 |     //Lower case letter
18 |     if(c>='a' && c<='y') return c+1;
19 |     if(c=='z') return 'a'; //'z'
20 | 
21 |     //Upper case letter
22 |     if(c>='a' && c<='y') return c+1;
23 |     if(c=='Z') return 'A';
24 | 
25 |     //Neither
26 |     return c;
27 | }
28 | 
29 | /* Check if vowel, and captialize if so */
30 | char capitaliseVowel(char c){
31 |     switch(c){
32 |         case 'a': return 'A';
33 |         case 'e': return 'E';
34 |         case 'i': return 'I';
35 |         case 'o': return 'O';
36 |         case 'u': return 'U';
37 | 
38 |         default: return c;
39 |     }
40 | }
41 | 
42 | void LetterChanges(char * str) {
43 |     int i;
44 | 
45 |     for(i=0;i<strlen(str);i++){
46 |         printf("%c",capitaliseVowel(shift_letter(str[i])));
47 |     }
48 | }
49 | 
50 | int main(void) {
51 |     LetterChanges(gets(stdin));
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/Easy/LongestWord.c:
--------------------------------------------------------------------------------
 1 | /* QUESTION:
 2 | Have the function LongestWord(sen) take the sen parameter being passed and return the largest word in the string. If there are two or more words that are the same length, return the first word from the string with that length. Ignore punctuation and assume sen will not be empty.
 3 | */
 4 | #include <stdio.h>
 5 | #include <string.h>
 6 | 
 7 | /*
 8 | Take note that for some reason, C does NOT have boolean types.
 9 | So we use unsigned char (with 0 and 1) instead.
10 | Unsigned char only has one byte.
11 | */
12 | unsigned char isLetter(char c){
13 |     //Lower case letter
14 |     int n = c-'a';
15 |     if(n>=0 && n<=26) return 1;
16 | 
17 |     //Upper case letter
18 |     n = c-'A';
19 |     if(n>=0 && n<=26) return 1;
20 | 
21 |     //Number
22 |     n = c-'0';
23 |     if(n>=0 && n<=9) return 1;
24 | 
25 |     return 0;
26 | }
27 | 
28 | void LongestWord(char * sen){
29 |     int startIndex = 0, maxStartIndex = 0;
30 |     int currLength = 0, maxLength = 0;
31 |     int i, len = strlen(sen);
32 | 
33 |     for(i=0;i<len;i++){
34 |         if(isLetter(sen[i])){ //we are at a letter
35 |             if(currLength==0) startIndex = i;
36 |             currLength++;
37 |         }
38 | 
39 |         if(!isLetter(sen[i]) || i==len-1){ //either not a letter, or reached the end of the string
40 |             if(currLength > maxLength){
41 |                 maxLength = currLength;
42 |                 maxStartIndex = startIndex;
43 |             }
44 |             currLength = 0;
45 |         }
46 |     }
47 | 
48 |     for(i=maxStartIndex;i<maxStartIndex+maxLength;i++){
49 |         printf("%c", sen[i]);
50 |     }
51 | }
52 | 
53 | int main(void) {
54 |     LongestWord(gets(stdin));
55 |     return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/Easy/VowelSquare.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function VowelSquare(strArr) take the strArr parameter being passed which will be a 2D matrix of some arbitrary size filled with letters from the alphabet, and determine if a 2x2 square composed entirely of vowels exists in the matrix. For example: strArr is ["abcd", "eikr", "oufj"] then this matrix looks like the following:
 4 | 
 5 | a b c d
 6 | e i k r
 7 | o u f j
 8 | 
 9 | Within this matrix there is a 2x2 square of vowels starting in the second row and first column, namely, ei, ou. If a 2x2 square of vowels is found your program should return the top-left position (row-column) of the square, so for this example your program should return 1-0. If no 2x2 square of vowels exists, then return the string not found. If there are multiple squares of vowels, return the one that is at the most top-left position in the whole matrix. The input matrix will at least be of size 2x2.
10 | ===============================================================================
11 | Input:["aqrst", "ukaei", "ffooo"]
12 | 
13 | Output:"1-2"
14 | 
15 | 
16 | Input:["gg", "ff"]
17 | 
18 | Output:"not found"
19 | */
20 | function isVowel(c){
21 | 	switch(c){
22 | 		case 'a': case 'A':
23 | 		case 'e': case 'E':
24 | 		case 'i': case 'I':
25 | 		case 'o': case 'O':
26 | 		case 'u': case 'U':
27 | 			return true;
28 | 		default:
29 | 			return false;
30 | 	}
31 | }
32 | 
33 | function VowelSquare(strArr) {
34 | 	var arr = [];
35 | 
36 |     var i,j;
37 |     //Make string array a 2D array.
38 |     for(i=0;i<strArr.length;i++){
39 |         arr.push(strArr[i].split(""));
40 |     }
41 | 
42 | 	for(i=0;i<arr.length-1;i++){
43 | 		for(j=0;j<arr[i].length-1;j++){
44 | 			if( isVowel(arr[i][j]) && isVowel(arr[i+1][j]) && isVowel(arr[i][j+1])  && isVowel(arr[i+1][j+1]) ){
45 | 				return i+"-"+j;
46 | 			}
47 | 		}
48 | 	}
49 | 	return "not found";
50 | }
51 | 
52 | // keep this function call here
53 | VowelSquare(readline());
54 | 


--------------------------------------------------------------------------------
/Hard/KaprekarsConstant.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function KaprekarsConstant(num) take the num parameter being passed which will be a 4-digit number with at least two distinct digits. Your program should perform the following routine on the number: Arrange the digits in descending order and in ascending order (adding zeroes to fit it to a 4-digit number), and subtract the smaller number from the bigger number. Then repeat the previous step. Performing this routine will always cause you to reach a fixed number: 6174. Then performing the routine on 6174 will always give you 6174 (7641 - 1467 = 6174). Your program should return the number of times this routine must be performed until 6174 is reached. For example: if num is 3524 your program should return 3 because of the following steps: (1) 5432 - 2345 = 3087, (2) 8730 - 0378 = 8352, (3) 8532 - 2358 = 6174.
 4 | 
 5 | Hard challenges are worth 15 points and you are not timed for them.
 6 | */
 7 | 
 8 | /* NOTE:
 9 | This is an interesting mathematical constant, wherein there are at most 8 iterations before we arrive at the constant 6174. Note also that repeating digits (eg. 1111, 2222 etc) will arrive at the constant 0000. For a full solution, we must account for this also.
10 | */
11 | 
12 | function KaprekarsConstant(num) {
13 | 	if(num == 6174) return 0; //reached the constant
14 | 	if(num == 0 || num == 1111 || num == 2222 || num == 3333 || num == 4444 || num == 5555 || num == 6666 || num == 7777 || num == 8888 || num == 9999) return 0; //special case
15 | 
16 | 	var numArr = [];
17 | 	var i;
18 | 
19 | 	numArr = num.toString().split("").sort(function(a,b){ return parseInt(b)-parseInt(a); }); //sort digits in descending order
20 | 	var l = numArr.length; for(i=0;i<4-l;i++) numArr.push(0); //add missing '0's to the back
21 | 
22 | 	n1 = parseInt(numArr.join(""));
23 | 	n2 = parseInt(numArr.reverse().join(""));
24 | 
25 |     //return 1;
26 | 	return 1+KaprekarsConstant(Math.abs(n2-n1));
27 | }
28 | 
29 | // keep this function call here
30 | KaprekarsConstant(readline());
31 | 


--------------------------------------------------------------------------------
/Easy/QuestionMarks.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function QuestionsMarks(str) take the str string parameter, which will contain single digit numbers, letters, and question marks, and check if there are exactly 3 question marks between every pair of two numbers that add up to 10. If so, then your program should return the string true, otherwise it should return the string false. If there aren't any two numbers that add up to 10 in the string, then your program should return false as well.
 4 | 
 5 | For example: if str is "arrb6???4xxbl5???eee5" then your program should return true because there are exactly 3 question marks between 6 and 4, and 3 question marks between 5 and 5 at the end of the string.
 6 | */
 7 | #include <stdio.h>
 8 | #include <string.h>
 9 | 
10 | /*
11 | Take note that for some reason, C does NOT have boolean types.
12 | So we use unsigned char (with 0 and 1) instead.
13 | unsigned char only has one byte.
14 | */
15 | unsigned char isNumber(char c){
16 |     return (c-'0'>=0 && c-'0'<10)?1:0;
17 | }
18 | 
19 | void QuestionMarks(char* str){
20 |     int prevNum = -1, i;
21 |     int nQuestionMarks = 0;
22 |     unsigned char has10 = 0;
23 | 
24 |     for(i=0;i<strlen(str);i++){
25 |         char c = str[i]; //note that we can use c (single char) because no 2 numbers will add to 10 that are 2 digits
26 |         //EXCEPT 10+0: Therefore, this solution is actually incomplete, and lacks a check for 10 + 0
27 |         if(isNumber(c)){
28 |             if(prevNum != -1){//previous number has a value
29 |                 if(prevNum + (int)(c-'0') == 10){
30 |                     has10 = 1;
31 |                     if(nQuestionMarks != 3){ //2 numbers add to 10 but have no ??? between them
32 |                         printf("false");
33 |                         return;
34 |                     }
35 |                 }
36 |             }
37 |             nQuestionMarks = 0; //reset question marks counter
38 |             prevNum = c-'0'; //convert from char to int
39 |         }
40 |         else if(c=='?'){
41 |             nQuestionMarks++;
42 |         }
43 |     }
44 | 
45 |     if(has10) printf("true");
46 |     else printf("false");
47 | }
48 | 
49 | int main(void){
50 |     QuestionMarks(gets(stdin));
51 | 
52 |     return 0
53 | }
54 | 


--------------------------------------------------------------------------------
/Easy/VowelSquare.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function VowelSquare(strArr) take the strArr parameter being passed which will be a 2D matrix of some arbitrary size filled with letters from the alphabet, and determine if a 2x2 square composed entirely of vowels exists in the matrix. For example: strArr is ["abcd", "eikr", "oufj"] then this matrix looks like the following:
 4 | 
 5 | a b c d
 6 | e i k r
 7 | o u f j
 8 | 
 9 | Within this matrix there is a 2x2 square of vowels starting in the second row and first column, namely, ei, ou. If a 2x2 square of vowels is found your program should return the top-left position (row-column) of the square, so for this example your program should return 1-0. If no 2x2 square of vowels exists, then return the string not found. If there are multiple squares of vowels, return the one that is at the most top-left position in the whole matrix. The input matrix will at least be of size 2x2.
10 | ===============================================================================
11 | Input:["aqrst", "ukaei", "ffooo"]
12 | 
13 | Output:"1-2"
14 | 
15 | 
16 | Input:["gg", "ff"]
17 | 
18 | Output:"not found"
19 | */
20 | #include <stdio.h>
21 | #include <string.h>
22 | 
23 | unsigned char isVowel(c){
24 | 	switch(c){
25 | 		case 'a': case 'A':
26 | 		case 'e': case 'E':
27 | 		case 'i': case 'I':
28 | 		case 'o': case 'O':
29 | 		case 'u': case 'U':
30 | 			return 1;
31 | 		default:
32 | 			return 0;
33 | 	}
34 | }
35 | 
36 | void VowelSquare(char * strArr[], int len) {
37 | 	int len2 = strlen(strArr[0]);
38 | 	char arr[len][len2];
39 | 	int i,j;
40 | 
41 | 	for(i=0;i<arr.length-1;i++){
42 | 		for(j=0;j<arr[i].length-1;j++){
43 | 			if( isVowel(arr[i][j]) && isVowel(arr[i+1][j]) && isVowel(arr[i][j+1])  && isVowel(arr[i+1][j+1]) ){
44 | 				printf("%d-%d",i,j);
45 | 				return;
46 | 			}
47 | 		}
48 | 	}
49 | 
50 | 	printf("not found");
51 | 	return;
52 | }
53 | 
54 | int main(void) {
55 | 	/* Note: In C you first have to initialize an array and set
56 | 	 it equal to the stdin to test your code with arrays. */
57 | 
58 | 	char * A[] = gets(stdin);
59 | 	int len = sizeof(A)/sizeof(A[0]); //take note that due to pointer issues, you need to find the size BEFORE passing it through a function
60 | 	VowelSquare(A,len);
61 | 	return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/Easy/QuestionMarks.js:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function QuestionsMarks(str) take the str string parameter, which will contain single digit numbers, letters, and question marks, and check if there are exactly 3 question marks between every pair of two numbers that add up to 10. If so, then your program should return the string true, otherwise it should return the string false. If there aren't any two numbers that add up to 10 in the string, then your program should return false as well.
 4 | 
 5 | For example: if str is "arrb6???4xxbl5???eee5" then your program should return true because there are exactly 3 question marks between 6 and 4, and 3 question marks between 5 and 5 at the end of the string.
 6 | */
 7 | 
 8 | function QuestionsMarks(_str) {
 9 |     //Replace all groups of non-numberic and non-question marks characters with "|".
10 |     //This is to separate out numbers which were previously separated by other characters
11 |     var str = _str.replace(new RegExp("([^0-9\\?]+)","gi"),"|");
12 | 
13 |     //Remove "|" characters which are next to question marks
14 |     //This is so that later when we are finding for "???" we won't have problems
15 |     str = str.replace(new RegExp("(\\?\\|)|(\\|\\?)","gi"),"?");
16 | 
17 |     //At this point, we have the numbers separated purely by '?'s and '|'s
18 |     var regNumbers = new RegExp("([0-9]+)","gi");
19 |     var i, result, results = [];
20 | 
21 |     //Get all the indexes of the numbers in this string
22 |     while(result = regNumbers.exec(str)){
23 |         results.push({
24 |             "number": parseInt(result),
25 |             "index": result.index
26 |         });
27 |     }
28 | 
29 |     var no10 = true;
30 |     var r1,r2;
31 |     for(i=0;i<results.length-1;i++){
32 |         r1 = results[i];
33 |         r2 = results[i+1];
34 | 
35 |         if(r1.number+r2.number != 10) continue;
36 |         no10 = false;
37 |         if(str.substring(r1.index+1,r2.index) != "???" ) return false;
38 |     }
39 | 
40 |     if(no10) return false;
41 |     
42 |     return true;
43 | }
44 | 
45 | //For testing purposes
46 | /*
47 | //n=-1;
48 | testcases = ["arrb6???4xxbl5???eee5","9???1???9??1???9","5??aaaaaaaaaaaaaaaaaaa?5?5"];
49 | readline = ()=>{
50 |     return testcases[i];
51 | }
52 | for(i=0;i<testcases.length;i++)
53 | //*/
54 | QuestionsMarks(readline());
55 | 


--------------------------------------------------------------------------------
/Hard/KaprekarsConstant.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | QUESTION:
 3 | Have the function KaprekarsConstant(num) take the num parameter being passed which will be a 4-digit number with at least two distinct digits. Your program should perform the following routine on the number: Arrange the digits in descending order and in ascending order (adding zeroes to fit it to a 4-digit number), and subtract the smaller number from the bigger number. Then repeat the previous step. Performing this routine will always cause you to reach a fixed number: 6174. Then performing the routine on 6174 will always give you 6174 (7641 - 1467 = 6174). Your program should return the number of times this routine must be performed until 6174 is reached. For example: if num is 3524 your program should return 3 because of the following steps: (1) 5432 - 2345 = 3087, (2) 8730 - 0378 = 8352, (3) 8532 - 2358 = 6174.
 4 | 
 5 | Hard challenges are worth 15 points and you are not timed for them.
 6 | */
 7 | 
 8 | /* NOTE:
 9 | This is an interesting mathematical constant, wherein there are at most 8 iterations before we arrive at the constant 6174. Note also that repeating digits (eg. 1111, 2222 etc) will arrive at the constant 0000. For a full solution, we must account for this also.
10 | */
11 | #include <stdio.h>
12 | #include <stdlib.h>
13 | 
14 | #define INT_LEN(n) (n<10)?1:(n<100)?2:(n<1000)?3:4
15 | #define POW_TEN(n) (n==3)?1000:(n==2)?100:(n==1)?10:1
16 | //#define ABS(n) (n>0)?n:-n
17 | 
18 | int cmpfunc (const void * a, const void * b) {
19 |    return ( *(int*)a - *(int*)b );
20 | }
21 | 
22 | int KaprekarsConstant(int num) {
23 | 	if(num == 6174) return 0; //reached the constant
24 | 	if(num == 0 || num == 1111 || num == 2222 || num == 3333 || num == 4444 || num == 5555 || num == 6666 || num == 7777 || num == 8888 || num == 9999) return 0; //special case
25 | 
26 | 	int numArr[4] = {0};
27 | 	int i;
28 | 
29 | 	int l = INT_LEN(num);
30 | 
31 | 	for(i=0;i<l;i++){
32 | 		numArr[i] = num%10;
33 | 		num = num/10;
34 | 	}
35 | 
36 | 	qsort(numArr, 4, sizeof(int), cmpfunc);
37 | 
38 | 	//for(i=0;i<4;i++) printf("%d ",numArr[i]); puts("");
39 | 
40 | 	int n1= 0; int n2 = 0; int ten;
41 | 
42 | 	for(i=0;i<4;i++){
43 | 	    ten = POW_TEN(i);
44 | 	    n1 += numArr[i]*ten;
45 | 	    n2 += numArr[3-i]*ten;
46 | 	}
47 | 
48 | 	return 1+KaprekarsConstant(n1-n2);
49 | }
50 | 
51 | int main(void){
52 | 	printf("%d",KaprekarsConstant(gets(stdin)));
53 | }
54 | 


--------------------------------------------------------------------------------
/Easy/CorrectPath.js:
--------------------------------------------------------------------------------
 1 | /* QUESTION:
 2 | Have the function CorrectPath(str) read the str parameter being passed, which will represent the movements made in a 5x5 grid of cells starting from the top left position. The characters in the input string will be entirely composed of: r, l, u, d, ?. Each of the characters stand for the direction to take within the grid, for example: r = right, l = left, u = up, d = down. Your goal is to determine what characters the question marks should be in order for a path to be created to go from the top left of the grid all the way to the bottom right without touching previously travelled on cells in the grid.
 3 | 
 4 | For example: if str is "r?d?drdd" then your program should output the final correct string that will allow a path to be formed from the top left of a 5x5 grid to the bottom right. For this input, your program should therefore return the string rrdrdrdd. There will only ever be one correct path and there will always be at least one question mark within the input string.
 5 | ================================================================================
 6 | Input:"???rrurdr?"
 7 | Output:"dddrrurdrd"
 8 | 
 9 | Input:"drdr??rrddd?"
10 | Output:"drdruurrdddd"
11 | */
12 | var N = 5; //size of grid
13 | 
14 | var dir = { //"[u|r|d|l]":[dx,dy]
15 | 	"u":[0,-1],
16 | 	"d":[0,1],
17 | 	"r":[1,0],
18 | 	"l":[-1,0]
19 | }
20 | 
21 | function CorrectPath(str){
22 | 	var i,j;
23 | 	var dirs = str.split("");
24 | 
25 | 	var grid = [];
26 | 	/* Generate a NxN grid, where each element in the grid represents the direction to take.
27 | 	Default is '?'
28 | 	*/
29 | 	for(i=0;i<N;i++){
30 | 		grid.push([]);
31 | 		for(j=0;j<N;j++){
32 | 			grid[i].push("?");
33 | 		}
34 | 	}
35 | 
36 | 	/*
37 | 	==Smarter way?==
38 | 	If we sum up the individual directions' dx and dy, we can get an idea of what's lacking from the difference in the sums and the total size of the grid (N=5).
39 | 	For eg. "???rrurdr?":
40 | 		[1,0]+[1,0]+[0,-1]+[1,0]+[0,1]+[1,0] = [4,0]
41 | 		[4,-4] - [4,0] = [0,-4]
42 | 		This means that if there are 4 '?'s, there needs to be 4'd's and 0'l/r's.
43 | 		If there are 5 '?'s, there might be 4'd's, 1'r', 1'l', so the final total is also [0,-4]
44 | 	*/
45 | 	var nQ = 0; //number of question marks to be found
46 | 	var diffSum = [N-1,-(N-1)]; //we need to traverse 4 spaces right and 4 spaces down
47 | 	for(i=0;i<dirs.length;i++){
48 | 		var c  = dirs[i];
49 | 		if(c == '?') nQ++;
50 | 		else{
51 | 			diffSum[0] -= dir[c][0];
52 | 			diffSum[1] -= dir[c][1];
53 | 		}
54 | 	}
55 | 
56 | 	var combos = generateCombos(nQ, diffSum);
57 | 
58 | 	return dirs;
59 | }
60 | 
61 | function generateCombos(nQ, diffSum){
62 | 	
63 | }
64 | 
65 | readline = ()=>{
66 | 	return "r?d?drdd";
67 | }
68 | 
69 | CorrectPath(readline());
70 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # MAC OS GIT IGNORE
  2 | # General
  3 | .DS_Store
  4 | .AppleDouble
  5 | .LSOverride
  6 | 
  7 | # Icon must end with two \r
  8 | Icon
  9 | 
 10 | # Thumbnails
 11 | ._*
 12 | 
 13 | # Files that might appear in the root of a volume
 14 | .DocumentRevisions-V100
 15 | .fseventsd
 16 | .Spotlight-V100
 17 | .TemporaryItems
 18 | .Trashes
 19 | .VolumeIcon.icns
 20 | .com.apple.timemachine.donotpresent
 21 | 
 22 | # Directories potentially created on remote AFP share
 23 | .AppleDB
 24 | .AppleDesktop
 25 | Network Trash Folder
 26 | Temporary Items
 27 | .apdisk
 28 | 
 29 | # PYTHON GIT IGNORE
 30 | 
 31 | # Byte-compiled / optimized / DLL files
 32 | __pycache__/
 33 | *.py[cod]
 34 | *$py.class
 35 | 
 36 | # C extensions
 37 | *.so
 38 | 
 39 | # Distribution / packaging
 40 | .Python
 41 | build/
 42 | develop-eggs/
 43 | dist/
 44 | downloads/
 45 | eggs/
 46 | .eggs/
 47 | lib/
 48 | lib64/
 49 | parts/
 50 | sdist/
 51 | var/
 52 | wheels/
 53 | pip-wheel-metadata/
 54 | share/python-wheels/
 55 | *.egg-info/
 56 | .installed.cfg
 57 | *.egg
 58 | MANIFEST
 59 | 
 60 | # PyInstaller
 61 | #  Usually these files are written by a python script from a template
 62 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 63 | *.manifest
 64 | *.spec
 65 | 
 66 | # Installer logs
 67 | pip-log.txt
 68 | pip-delete-this-directory.txt
 69 | 
 70 | # Unit test / coverage reports
 71 | htmlcov/
 72 | .tox/
 73 | .nox/
 74 | .coverage
 75 | .coverage.*
 76 | .cache
 77 | nosetests.xml
 78 | coverage.xml
 79 | *.cover
 80 | .hypothesis/
 81 | .pytest_cache/
 82 | 
 83 | # Translations
 84 | *.mo
 85 | *.pot
 86 | 
 87 | # Django stuff:
 88 | *.log
 89 | local_settings.py
 90 | db.sqlite3
 91 | 
 92 | # Flask stuff:
 93 | instance/
 94 | .webassets-cache
 95 | 
 96 | # Scrapy stuff:
 97 | .scrapy
 98 | 
 99 | # Sphinx documentation
100 | docs/_build/
101 | 
102 | # PyBuilder
103 | target/
104 | 
105 | # Jupyter Notebook
106 | .ipynb_checkpoints
107 | 
108 | # IPython
109 | profile_default/
110 | ipython_config.py
111 | 
112 | # pyenv
113 | .python-version
114 | 
115 | # celery beat schedule file
116 | celerybeat-schedule
117 | 
118 | # SageMath parsed files
119 | *.sage.py
120 | 
121 | # Environments
122 | .env
123 | .venv
124 | env/
125 | venv/
126 | ENV/
127 | env.bak/
128 | venv.bak/
129 | 
130 | # Spyder project settings
131 | .spyderproject
132 | .spyproject
133 | 
134 | # Rope project settings
135 | .ropeproject
136 | 
137 | # mkdocs documentation
138 | /site
139 | 
140 | # mypy
141 | .mypy_cache/
142 | .dmypy.json
143 | dmypy.json
144 | 
145 | # Pyre type checker
146 | .pyre/
147 | 
148 | #C++ Gitignore
149 | # Prerequisites
150 | *.d
151 | 
152 | # Compiled Object files
153 | *.slo
154 | *.lo
155 | *.o
156 | *.obj
157 | 
158 | # Precompiled Headers
159 | *.gch
160 | *.pch
161 | 
162 | # Compiled Dynamic libraries
163 | *.so
164 | *.dylib
165 | *.dll
166 | 
167 | # Fortran module files
168 | *.mod
169 | *.smod
170 | 
171 | # Compiled Static libraries
172 | *.lai
173 | *.la
174 | *.a
175 | *.lib
176 | 
177 | # Executables
178 | *.exe
179 | *.out
180 | *.app
181 | 


--------------------------------------------------------------------------------
/Hard/MaximalSquare.js:
--------------------------------------------------------------------------------
 1 | /* QUESTION:
 2 | Have the function MaximalSquare(strArr) take the strArr parameter being passed which will be a 2D matrix of 0 and 1's, and determine the area of the largest square submatrix that contains all 1's. A square submatrix is one of equal width and height, and your program should return the area of the largest submatrix that contains only 1's. For example: if strArr is ["10100", "10111", "11111", "10010"] then this looks like the following matrix:
 3 | 
 4 | 1 0 1 0 0
 5 | 1 0 1 1 1
 6 | 1 1 1 1 1
 7 | 1 0 0 1 0
 8 | 
 9 | For the input above, you can see the bolded 1's create the largest square submatrix of size 2x2, so your program should return the area which is 4. You can assume the input will not be empty.
10 | */
11 | 
12 | //Modified 2D Maximal Square algo (dynamic programming)
13 | //Skips if the max square sum is not k*k
14 | 
15 | function MaximalSquare(strArr) {
16 |     var arr = [];
17 | 
18 |     var i,j;
19 |     //Make string array a 2D array.
20 |     for(i=0;i<strArr.length;i++){
21 |         arr.push(strArr[i].split(""));
22 |     }
23 | 
24 |     var anyOnes = false;
25 |     //Create the DP array/summation table
26 | 	//Single pass - O(n^2)
27 |     for(i=0;i<arr.length;i++){
28 |         for(j=0;j<arr[i].length;j++){
29 |             arr[i][j] = parseInt(arr[i][j]); //make int first cos it's parsed as a string
30 |             if(arr[i][j]==1) anyOnes = true;
31 | 
32 |             if(i>0) arr[i][j] += arr[i-1][j];
33 |             if(j>0) arr[i][j] += arr[i][j-1];
34 |             if(i>0 && j>0) arr[i][j] -= arr[i-1][j-1];             //avoid double counting
35 |         }
36 |     }
37 | 
38 |     if(!anyOnes) return 0;
39 | 
40 |     mx = 1;
41 |     sm = 0;
42 | 
43 | 	//Pass over again, with matrix k - O(n^2*k)
44 |     for(i=0;i<arr.length;i++) for(j=0;j<arr[i].length;j++){ //start coord
45 |         for(k=1;k<arr.length;k++){ //size of matrix, skip 1x1 because we know it'll be one unless there are no ones (checked beforehand)
46 | 			/* End coordinates */
47 |             end_i = i+k;
48 |             end_j = j+k;
49 | 			if(end_i>=arr.length || end_j>=arr[i].length) break;
50 | 
51 | 			/* Sum from DP summation array/table */
52 |             sm = arr[end_i][end_j]; //sum from (0,0) to (end_i, end_j) - O(1)
53 |             if(i>0) sm -= arr[i-1][end_j]; //exclude subrect (0,0) to (i-1,end_j) - O(1)
54 |             if(j>0) sm -= arr[end_i][j-1]; //exclude subrect (0,0) to (end_i,j-1) - O(1)
55 |             if(i>0 && j>0) sm += arr[i-1][j-1]; //include back the double counted excluded (0,0) to (i-1,j-1) subrect - O(1)
56 |             //The sum is finally here: sum from (i,j) to (end_i,end_j) - total O(4)
57 | 
58 |             if(sm!=(k+1)*(k+1)) continue;
59 | 
60 |             if(sm>mx){
61 |                 mx = sm;
62 |             }
63 |         }
64 |     }
65 | 
66 |     // Return mx. Total O(2*n^2*k*4) = O(8*n^2*k)
67 |     return mx;
68 | }
69 | 
70 | //For testing purposes
71 | /*
72 | readline = ()=>{
73 | 	return ["0111", "1111", "1111", "1111"];
74 | }
75 | //*/
76 | 
77 | // keep this function call here
78 | MaximalSquare(readline());
79 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # CoderByte Solutions
 2 | 
 3 | Repository of [CoderByte](https://www.coderbyte.com/) solutions for the free challenges.
 4 | 
 5 | 
 6 | Completed in different programming languages (mainly JS and C).
 7 | 
 8 | 
 9 | ## Easy
10 | Longest Word [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Longest%20Word:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Longest%20Word:C)
11 | 
12 | 
13 | First Factorial [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:First%20Factorial:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:First%20Factorial:C)
14 | 
15 | First Reverse [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:First%20Reverse:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:First%20Reverse:C)
16 | 
17 | Letter Changes [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Letter%20Changes:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Letter%20Changes:C)
18 | 
19 | Simple Adding [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Simple%20Adding:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Simple%20Adding:C)
20 | 
21 | Letter Capitalize [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Letter%20Capitalize:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Letter%20Capitalize:C)
22 | 
23 | Letter Changes [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Letter%20Changes:JavaScript)
24 | 
25 | Simple Symbols [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Simple%20Symbols:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Simple%20Symbols:C)
26 | 
27 | Check Nums [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Check%20Nums:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Check%20Nums:C)
28 | 
29 | Time Convert [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Time%20Convert:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Time%20Convert:C)
30 | 
31 | Alphabet Soup [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Alphabet%20Soup:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Alphabet%20Soup:C)
32 | 
33 | Question Marks [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Question%20Marks:JavaScript) [![C](https://img.shields.io/badge/C-solved-green.svg)](https://www.coderbyte.com/results/Samleo:Question%20Marks:C)
34 | 
35 | Vowel Square [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Vowel%20Square:JavaScript) [![C](https://img.shields.io/badge/C-solved-green.svg)](https://www.coderbyte.com/results/Samleo:Vowel%20Square:C)
36 | 
37 | Correct Path 
38 | 
39 | 
40 | ## Hard
41 | Maximal Square [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Maximal%20Square:JavaScript)
42 | 
43 | Pentagonal Number [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Pentagonal%20Number:JavaScript) [![C](https://img.shields.io/badge/C-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Pentagonal%20Number:C) [![Python](https://img.shields.io/badge/Python-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Pentagonal%20Number:Python)
44 | 
45 | Kaprekars Constant [![JavaScript](https://img.shields.io/badge/JavaScript-solved-brightgreen.svg)](https://www.coderbyte.com/results/Samleo:Kaprekars%20Constant:JavaScript)
46 | 


--------------------------------------------------------------------------------