├── Binary Converter
├── Bracket Matcher
├── Caesar Cipher
├── Consecutive
├── Dash Insert II
├── Distinct List
├── Division
├── Fibonacci Checker
├── Formatted Division
├── Look Say Sequence
├── Multiple Brackets
├── Number Encoding
├── Number Search
├── Palindrome Two
├── Prime Mover
├── Prime Time
├── README.md
├── Simple Mode
├── String Scramble
├── Swap II
├── Three Five Multiples
└── Triple Double


/Binary Converter:
--------------------------------------------------------------------------------
 1 | //won't work if binary exceeds normal 8-bit length without spaces
 2 | /*Using the JavaScript language, have the function BinaryConverter(str) 
 3 | return the decimal form of the binary value. For example:
 4 | if 101 is passed return 5, or if 1000 is passed return 8. */
 5 | 
 6 | function BinaryConverter(str) { 
 7 | count =0;
 8 |   arr2 =str.split("").reverse().join("");
 9 |   arr=[1,2,4,8,16,32, 64, 128];
10 |   for(var i=0; i<arr2.length; i++){
11 |     if(arr2[i]=="1"){
12 |     count+= arr[i];}
13 |   }
14 | return count;
15 | }
16 | 


--------------------------------------------------------------------------------
/Bracket Matcher:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function BracketMatcher(str)
 2 | take the str parameter being passed and return 1 if the brackets are correctly
 3 | matched and each one is accounted for. Otherwise return 0. For example: if str is
 4 | "(hello (world))", then the output should be 1, but if str is "((hello (world))" the the output should be 0 because 
 5 | the brackets do not correctly match up. Only "(" and ")" will be used as brackets. If str contains no brackets return 1. */
 6 | 
 7 | function BracketMatcher(str){
 8 |     var left=0;
 9 |     var right=0;
10 |     for(var i=0; i<str.length; i++){
11 |         if(str[i]==="("){
12 |             left++;
13 |         }
14 |         else if(str[i]===")"){
15 |             right++;
16 |         }
17 |     }
18 | if(right===left){
19 |     return 1;
20 |   }
21 |     else{
22 |       return 0;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/Caesar Cipher:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function CaesarCipher(str,num)
 2 | take the str parameter and perform a Caesar Cipher shift on it using the num 
 3 | parameter as the shifting number. A Caesar Cipher works by shifting each letter
 4 | in the string N places down in the alphabet (in this case N will be num). 
 5 | Punctuation, spaces, and capitalization should remain intact.
 6 | For example if the string is "Caesar Cipher" and num is 2 the output should be "Ecguct Ekrjgt"*/
 7 | 
 8 | function CaesarCipher(str,num) { 
 9 |     var arr =[];
10 |     var re = /[a-z]/i;
11 |     for(var i=0; i<str.length; i++){
12 |         if(str[i].match(re)){
13 |             arr.push(str.charCodeAt(i)+num);
14 |         }
15 |         else{
16 |             arr.push(str.charCodeAt(i));
17 |         }
18 |     }
19 |     for(var i=0; i<arr.length; i++){
20 |         arr[i] = String.fromCharCode(arr[i]);
21 |     }
22 |     return arr.join("");
23 | }
24 | 


--------------------------------------------------------------------------------
/Consecutive:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function Consecutive(arr) 
 2 | take the array of integers stored in arr and return the minimum number 
 3 | of integers needed to make the contents of arr consecutive from the lowest 
 4 | number to the highest number. For example: If arr contains [4, 8, 6] then the 
 5 | output should be 2 because two numbers need to be added to the array (5 and 7) to make it a consecutive
 6 | array of numbers from 4 to 8. Negative numbers may be entered as parameters and no array will have less than 2 elements.*/ 
 7 | 
 8 | function Consecutive(arr) { 
 9 |   var min = Math.min.apply(Math, arr);
10 |   var max = Math.max.apply(Math, arr);
11 |   var num = (max-min)-arr.length+1;
12 |   return num;
13 |   
14 | }
15 | 


--------------------------------------------------------------------------------
/Dash Insert II:
--------------------------------------------------------------------------------
 1 | //Works in every case but with zero, should be an easy fix
 2 | /*Using the JavaScript language, have the function DashInsertII(str) 
 3 | insert dashes ('-') between each two odd numbers and insert asterisks ('*') between each two even numbers in str.
 4 | For example: if str is 4546793 the output should be 454*67-9-3. Don't count zero as an odd or even number.*/
 5 | 
 6 | function DashInsertII(num) { 
 7 | var arr =num.toString().split("");
 8 |   var arr2 =[];
 9 |   for(var i=0; i<arr.length; i++){
10 |     if(arr[i]%2===0 && arr[i+1]%2===0){
11 |       arr2.push(arr[i], "*");
12 |     }
13 |     else if(arr[i]%2!==0 && arr[i+1]%2!==0){
14 |       arr2.push(arr[i], "-");
15 |     }
16 |     else{
17 |       arr2.push(arr[i]);
18 |     }
19 |   }
20 |   if(arr2[arr2.length-1]==="-" || arr2[arr2.length-1]==="*"){
21 |     arr2.pop(arr2[arr2.length-1]);
22 |   }
23 |   return arr2.join("");
24 |          
25 | }
26 | 


--------------------------------------------------------------------------------
/Distinct List:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function DistinctList(arr)
 2 | take the array of numbers stored in arr and determine the total number 
 3 | of duplicate entries. For example if the input is [1, 2, 2, 2, 3]
 4 | then your program should output 2 because there are two duplicates of one of the elements. */
 5 | 
 6 | function DistinctList(arr){
 7 |     var duplicates=0;
 8 |     for(var i=0; i<arr.length; i++){
 9 |         for(var j=0; j<arr.length; j++){
10 |             if(arr[i]===arr[j] && i!==j){
11 |                 duplicates++;
12 |                 arr.splice(arr.indexOf(arr[i]), 1)
13 |             }
14 |         }
15 |     }
16 |    for(var i=0; i<arr.length; i++){
17 |         for(var j=0; j<arr.length; j++){
18 |             if(arr[i]===arr[j] && i!==j){
19 |                 duplicates++;
20 |                 arr.splice(arr.indexOf(arr[i]), 1)
21 |             }
22 |         }
23 |     }
24 |     return duplicates;
25 | }
26 | 


--------------------------------------------------------------------------------
/Division:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function Division(num1,num2)
 2 | take both parameters being passed and return the Greatest Common Factor.
 3 | That is, return the greatest number that evenly goes into both numbers with no remainder. 
 4 | For example: 12 and 16 both are divisible
 5 | by 1, 2, and 4 so the output should be 4. The range for both parameters will be from 1 to 10^3. */
 6 | 
 7 | function Division(num1,num2) { 
 8 |   for(var i=num1; i>0; i--){
 9 |     if(num1%i==0 && num2%i==0){
10 |       return i;
11 |     }
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/Fibonacci Checker:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function FibonacciChecker(num) return the string yes if the number
 2 | given is part of the Fibonacci sequence. This sequence is defined by: Fn = Fn-1 + Fn-2, 
 3 | which means to find Fn you add the previous two numbers up.
 4 | The first two numbers are 0 and 1, then comes 1, 2, 3, 5 etc. If num is not in the Fibonacci
 5 | sequence, return the string no. */
 6 | 
 7 | function FibonacciChecker(num) { 
 8 |   if(num===2||num===3){
 9 |     return "yes";
10 |   }
11 |    var num1=0;
12 |     var num2=1;
13 |     var num3=1;
14 |   for(var i=0; i<=num; i++){
15 |       if(num1===num){return "yes";}
16 |         num1 = num2;
17 |         num2 = num3;
18 |         num3 = num1+num2;
19 |       }
20 |   return "no";
21 |          
22 | }
23 | 


--------------------------------------------------------------------------------
/Formatted Division:
--------------------------------------------------------------------------------
 1 | //works for most cases, but need to figure out the significant digits
 2 | 
 3 | /*Using the JavaScript language, have the function FormattedDivision(num1,num2)
 4 | take both parameters being passed, divide num1 by num2, and return the result as a 
 5 | string with properly formatted commas and 4 significant digits after the decimal place. 
 6 | For example: if num1 is 123456789 and num2
 7 | is 10000 the output should be "12,345.6789". The output must contain a number in the one's place even if it is a zero. */
 8 | 
 9 | function FormattedDivision(num1,num2) { 
10 | var div = parseFloat(num1/num2);
11 | var arr = div.toString().split("");
12 | var len = arr.length-1;  
13 |   var dot =0;
14 |   for(var i=len; i>0; i--){
15 |     if(arr[i]==="."){
16 |       dot++;
17 |     }
18 |   }
19 |   if(dot===0){
20 |     arr.push(".", 0, 0, 0, 0);
21 |   }
22 |  for(var i=len; i>0; i--){
23 |     if(arr[i+3]==="."){
24 |       arr.splice(i, 0, ",");
25 |     }
26 |     if(arr[i+3]===","){
27 |       arr.splice(i, 0, ",");
28 |     }
29 |   }
30 |   return arr.join(""); 
31 | }
32 | 


--------------------------------------------------------------------------------
/Look Say Sequence:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function LookSaySequence(num) 
 2 | take the num parameter being passed and return the next number in the sequence
 3 | according to the following rule: to generate the next number in a sequence read 
 4 | off the digits of the given number, counting the number of digits in groups of 
 5 | the same digit. For example, the sequence beginning with 1 would be: 1, 11, 21, 1211, ...
 6 | The 11 comes from there being "one 1" before it and the 21 
 7 | comes from there being "two 1's" before it. So your program should return the next number in the sequence given num. */
 8 | 
 9 | function LookSaySequence(num) { 
10 | var arr = num.toString().split("");
11 | var arr2=[];  
12 |   for(var i=0; i<arr.length; i++){
13 |     if(arr[i+1]!==arr[i]){
14 |       arr2.push(1, arr[i]);
15 |     }
16 |     if(arr[i+1]===arr[i] && arr[i+2]===arr[i]){
17 |       arr2.push(3, arr[i]);
18 |       i+=2;
19 |     }
20 |     if(arr[i+1]===arr[i]){
21 |       arr2.push(2, arr[i]);
22 |       i+=1;
23 |     }
24 |   }
25 | return arr2.join("");
26 | }
27 | 


--------------------------------------------------------------------------------
/Multiple Brackets:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function MultipleBrackets(str) 
 2 | take the str parameter being passed and return 1 #ofBrackets if the brackets 
 3 | are correctly matched and each one is accounted for. Otherwise return 0. 
 4 | For example: if str is "(hello [world])(!)", then the output should be 1 3 because
 5 | all the brackets are matched and there are 3 pairs of brackets, but if str is "((hello [world])" 
 6 | the the output should be 0 because the brackets do not correctly match up. 
 7 | Only "(", ")", "[", and "]" will be used as brackets. If str contains no brackets return 1. */
 8 | 
 9 | function MultipleBrackets(str) { 
10 |   var squL =0;
11 |   var squR =0;
12 |   var curvL =0;
13 |   var curvR =0;
14 |   for(var i=0; i<str.length; i++){
15 |     if(str[i]==="("){
16 |       curvL++;}
17 |     if(str[i]===")"){
18 |       curvR++;}
19 |     if(str[i]==="["){
20 |       squL++;}
21 |     if(str[i]==="]"){
22 |       squR++;}
23 |   }
24 |   if(curvL===0&&curvR===0&&squL===0&&squR===0){
25 |     return 1;
26 |   }
27 |   else if(curvL===curvR && squL===squR){
28 |     return 1 +" "+ (curvL+squL);
29 |   }
30 |   else 
31 |     return 0;
32 |          
33 | }
34 | 


--------------------------------------------------------------------------------
/Number Encoding:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function NumberEncoding(str)
 2 | take the str parameter and encode the message according to the following rule: 
 3 | encode every letter into its corresponding numbered position in the alphabet. 
 4 | Symbols and spaces will also be used in the input. For example: if str is "af5c a#!" 
 5 | then your program should return 1653 1#!. */
 6 | 
 7 | function NumberEncoding(str) { 
 8 |   var re = /[a-z]/i;
 9 |   var newStr=[];
10 |   for(var i=0; i<str.length; i++){
11 |     if(str[i].match(re)){
12 |       newStr.push(str.charCodeAt(i)-96);
13 |     }
14 |     else{
15 |       newStr.push(str[i]);
16 |     }
17 |   }
18 |   return newStr.join("");
19 |   }
20 | 


--------------------------------------------------------------------------------
/Number Search:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function NumberSearch(str) take the str parameter,
 2 | search for all the numbers in the string, add them together, then return that final number
 3 | divided by the total amount of letters in the string. For example: if str is "Hello6 9World 2, Nic8e D7ay!" 
 4 | the output should be 2. First if you add up all the numbers, 6 + 9 + 2 + 8 + 7 you get 32. Then there are 17
 5 | letters in the string. 32 / 17 = 1.882, and the final answer should be rounded to the nearest whole number,
 6 | so the answer is 2. Only single digit numbers separated by spaces will be used throughout 
 7 | the whole string (So this won't ever be the case: hello44444 world). Each string will also have at least one letter. */
 8 | 
 9 | function NumberSearch(str) { 
10 | var re = /[0-9]/;
11 |   var re2 = /[a-z]/i;
12 |   var num=0;
13 |   var letter=0;
14 |   for(var i=0; i<str.length; i++){
15 |     if(str[i].match(re)){
16 |        num += parseInt(str[i]);
17 |        }
18 |     if(str[i].match(re2)){
19 |       letter++;
20 |     }
21 |   }
22 |   var outp=Math.round(num/letter);
23 |   return outp;
24 |          
25 | }
26 | 


--------------------------------------------------------------------------------
/Palindrome Two:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function PalindromeTwo(str)
 2 | take the str parameter being passed and return the string true if the parameter is a palindrome, 
 3 | (the string is the same forward as it is backward) otherwise return the string false. 
 4 | The parameter entered may have punctuation and symbols but they should not affect whether the string is in fact a palindrome.
 5 | For example: "Anne, I vote more cars race Rome-to-Vienna" should return true. */
 6 | 
 7 | function PalindromeTwo(str) { 
 8 | var re = /[a-zA-Z]/;
 9 |   var arr = [];
10 |   for(var i=0; i<str.length; i++){
11 |     if(str.charAt(i).match(re)){
12 |       arr.push(str.charAt(i).toLowerCase());
13 |     }
14 |   }
15 |     var hold = arr.join("");
16 |     arr = arr.reverse().join("");
17 |   if(arr==hold){
18 |     return true;
19 |   }
20 |   else{
21 |     return false;
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/Prime Mover:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function PrimeMover(num) return the numth prime number. 
 2 | The range will be from 1 to 10^4. For example: if num is 16 the output should be 53 as 53 is the 16th prime number. */
 3 | 
 4 | function PrimeMover(num) { 
 5 |   if(num==1){
 6 |     return 2;
 7 |   }
 8 |   if(num==2){
 9 |     return 3;
10 |   }
11 |   var primes=1;
12 |   for(var i=3; i<100000; i++){
13 |     var prime=0;
14 |       for(var j=2; j<i; j++){
15 |         if(i%j==0){
16 |           prime++;
17 |         }
18 |       }
19 |       if(prime==0){
20 |         primes++;
21 |       }
22 |      if(primes==num){
23 |         return i;
24 |       }
25 |   }  
26 | }
27 | 


--------------------------------------------------------------------------------
/Prime Time:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function PrimeTime(num) 
 2 | take the num parameter being passed and return the string true if the parameter is a prime number,
 3 | otherwise return the string false. The range will be between 1 and 2^16.*/
 4 | 
 5 | function PrimeTime(num) { 
 6 |     var one =0;
 7 |     var two =0;
 8 |   for( var i=2; i<num; i++){
 9 |     if(num%i==0){
10 |         one++;
11 |     }
12 |     else{
13 |         two++;
14 |     }
15 |   }
16 |     if(one==0){
17 |       return true;
18 |     }
19 |     else{
20 |       return false;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | CoderByte-Medium-Problems
2 | =========================
3 | 


--------------------------------------------------------------------------------
/Simple Mode:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function SimpleMode(arr) 
 2 | take the array of numbers stored in arr and return the number that 
 3 | appears most frequently (the mode). For example: if arr contains 
 4 | [10, 4, 5, 2, 4] the output should be 4. If there is more than one 
 5 | mode return the one that appeared in the array first (ie. [5, 10, 10, 6, 5]
 6 | should return 5 because it appeared first). If there is no mode return -1. The array will not be empty. */
 7 | 
 8 | function SimpleMode(arr){
 9 | var mode=0;
10 | var count2=0;
11 | for(var i=0; i<arr.length; i++){
12 |     var count=0;
13 |     for(var j=0; j<arr.length; j++){
14 |         if(arr[i] == arr[j] && j!==i){
15 |             count++;
16 |         }
17 |         if(count>count2){
18 |             mode = arr[i];
19 |             count2 = count;
20 |             count =0;
21 |         }
22 |     }
23 | }
24 | if(count2==0){
25 |     return -1;
26 |     }
27 | return mode;
28 | }
29 | 


--------------------------------------------------------------------------------
/String Scramble:
--------------------------------------------------------------------------------
 1 | //This works for almost all inputs, working to fix issues
 2 | /*Using the JavaScript language, have the function StringScramble(str1,str2)
 3 | take both parameters being passed and return the string true if a portion of str1 
 4 | characters can be rearranged to match str2, otherwise return the string false. For example: if str1 is "rkqodlw"
 5 | and str2 is "world" the output should return true. Punctuation and symbols will not be entered with the parameters. */
 6 | 
 7 | function StringScramble(str1,str2) { 
 8 |   var arr=[];
 9 |   for(i=0; i<str2.length; i++){
10 |     for(j=0; j<str1.length; j++){
11 |     if(str1.charAt(j) == str2.charAt(i)){
12 |       arr.push(str1.charAt(j));
13 |     }
14 |   }
15 |   }
16 | arr = arr.join("");
17 |   if(arr==str2){
18 |     return true;}
19 |   else{return false;}
20 |          
21 | }
22 | 


--------------------------------------------------------------------------------
/Swap II:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function SwapII(str) 
 2 | take the str parameter and swap the case of each character.
 3 | Then, if a letter is between two numbers (without separation),
 4 | switch the places of the two numbers. For example: if str is "6Hello4 -8World, 7 yes3" 
 5 | the output should be 4hELLO6 -8wORLD, 7 YES3. */
 6 | 
 7 | function SwapII(str){
 8 |     var re= /[a-z]/;
 9 |     var re2= /[A-Z]/;
10 |     var re3= /[0-9]/;
11 |     var re4= /[a-z]/i;
12 |     var arr=[];
13 |     for(var i=0; i<str.length; i++){
14 |         if(str.charAt(i).match(re)){
15 |             arr.push(str[i].toUpperCase());
16 |         }
17 |         else if(str[i].match(re2)){
18 |             arr.push(str[i].toLowerCase());
19 |         }
20 |         else{
21 |             arr.push(str[i]);
22 |         }
23 |     }
24 | for(var i=0; i<arr.length; i++){
25 |     if(arr[i].match(re3)){
26 |         for(var j=i+1; j<arr.length; j++){
27 |             if(arr[j] == " "){
28 |                 break;
29 |             }
30 |             else if(arr[j].match(re3)){
31 |                 var hold = arr[i];
32 |                 arr[i]=arr[j];
33 |                 arr[j]=hold;
34 |             }
35 |         }
36 |     }
37 | }
38 | return arr.join("");
39 | }  
40 | 


--------------------------------------------------------------------------------
/Three Five Multiples:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function ThreeFiveMultiples(num) 
 2 | return the sum of all the multiples of 3 and 5 that are below num. For example: 
 3 | if num is 10, the multiples of 3 and 5 that are below 10 are 3, 5, 6, and 9, 
 4 | and adding them up you get 23, so your program should return 23. The integer being passed will be between 1 and 100. */
 5 | 
 6 | function ThreeFiveMultiples(num) { 
 7 |     var arr = [];
 8 |     var tot=0;
 9 |    for(var i=num-1; i>1; i--){
10 |         if(i%5===0 || i%3===0){
11 |             arr.push(i);
12 |         }
13 |     }
14 |     for(var i=0; i<arr.length; i++){
15 |         tot = tot+ arr[i];
16 |     }
17 |     return tot;
18 | }
19 | 


--------------------------------------------------------------------------------
/Triple Double:
--------------------------------------------------------------------------------
 1 | /*Using the JavaScript language, have the function TripleDouble(num1,num2)
 2 | take both parameters being passed, and return 1 if there is a straight triple
 3 | of a number at any place in num1 and also a straight double of the same number in num2. 
 4 | For example: if num1 equals 451999277 and num2 equals 41177722899, then return 1 because
 5 | in the first parameter you have the straight triple 999 and you have a straight double,
 6 | 99, of the same number in the second parameter. If this isn't the case, return 0.*/
 7 | 
 8 | function TripleDouble(num1,num2) { 
 9 | var arr =num1.toString().split("");
10 |   var num =0;
11 |   for(var i=0; i<arr.length; i++){
12 |     if(arr[i]===arr[i+1] && arr[i]===arr[i+2]){
13 |       num = arr[i];
14 |       break;
15 |     }
16 |   }
17 | var arr2 =num2.toString().split("");
18 |   for(var i=0; i<arr2.length; i++){
19 |     if(arr2[i]===arr2[i+1] && arr2[i]===num){
20 |       return 1;
21 |     }
22 |   }
23 |   return 0;
24 | }
25 | 


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