freecodecamp code JS

Seek and Destroy

function destroyer(...arr) {
  //console.log(arr);
  let arr0=[...arr];//equal arr
  //console.log(arr0)
  let arr1=[...arr];
  let arr2= arr1.shift();
  //console.log(arr2); /first element/
  //console.log(arr1); /rest elements/
  let newArr=[]
  for (let i=0; i<arr2.length; i++) {
    if(arr1.indexOf(arr2[i]) === -1) {
      newArr.push(arr2[i]);
    }
    //console.log(arr2[i]);
  }
  return newArr;
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);
console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
function destroyer(arr,...valsToRemove) {
  console.log(arr);
  console.log(valsToRemove);
  return arr.filter(elem => !valsToRemove.includes(elem));
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);

+++++++++++++++++++++++++++++++++++++++++++++++

DNA Pairing

function pairElement(str) {
  let newArr=[];
  for (let elem of str) {
  //for (let i=0; i<str.length; i++) {
    //console.log(str[i]);
    if (str[i] === 'A') {
      newArr.push(["A","T"])
    }
    else if (str[i] === 'T') {
      newArr.push(["T","A"])
    }
    else if (str[i] === 'C') {
      newArr.push(["C","G"])
    }    
    else if (str[i] === 'G') {
      newArr.push(["G","C"])
    }  
  }
  return newArr;
}

pairElement("GCG");


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
function pairElement(str) {
  let arr = str.split('');
  let pair = {
    A: 'T',
    T: 'A',
    C: 'G',
    G: 'C'
  }
  return arr.map(elem => [elem,pair[elem]]);
}

pairElement("GCG");
console.log(pairElement("GCG"));

---

Missing letters

---

+++++++++++++++++++++++++++++++++++++

function fearNotLetter(str) {
  let arr = str.split('');
  let alpha = "abcdefghijklmnopqrstuvwxyz";
  let arr1 = alpha.split('');
  let res1 = arr.map(elem => arr1.indexOf(elem));
  console.log(res1);
  let res2 = res1.filter(elem => elem-res1[res1.indexOf(elem)-1]>1);
  console.log(res2);
  let resFinal = arr1[res2-1];
  console.log(resFinal);
  return resFinal;
}

fearNotLetter("abce");

**

Sorted Union

**

function uniteUnique(...arr) {
  //console.log(arr)
  let arr1 = arr.reduce((a,b) => a.concat(b));
  console.log(arr1);
  //return arr;
  
  let newArr=[];
  for (let i=0; i<arr1.length; i++) {
    if (newArr.indexOf(arr1[i])===-1) {
      newArr.push(arr1[i]);
    }
    //console.log(arr1[i])
    //console.log(newArr.indexOf(arr1[i])=== -1)
    //console.log(newArr);
  }
  return newArr;
}

uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);
//console.log(uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]));

++++++++++++++++++++++++++++++++++++++++
Search and Replace

在这里插入代码function myReplace(str, before, after) {
  let newArr = str.split(' ');
  let ind1 = newArr.indexOf(before);
  //console.log(ind1);

  if (before.match(/^[A-Z]/)) {
    after = after[0].toUpperCase() + after.slice(1)
  }
  else {after = after[0].toLowerCase() + after.slice(1)}
  
  //console.log(after)
  newArr[ind1] = after;
  let newStr = newArr.join(' ');
  //console.log(newStr);
  return newStr;
}



myReplace("He is Sleeping on the couch", "Sleeping", "sitting");
console.log(myReplace("He is Sleeping on the couch", "Sleeping", "sitting"))
++++++++++++++++++++++++++++++++++++++++++++++++++++++++
**

**## drop it**

**
function dropElements(arr, func) {
  return arr.filter(elem => func(elem));
}

let a = dropElements([0, 1, 0, 1], function(n) {return n === 1; });
console.log(a);

**++++++++++++++++++++++++++++++++++++++++++++++++

Steamroller**

function steamrollArray(arr) {
const flattenedArray = [];
// Loop over array contents
for (let i = 0; i < arr.length; i++) {
if (Array.isArray(arr[i])) {
flattenedArray.push(…steamrollArray(arr[i]));
console.log(…steamrollArray(arr[i]))
} else {
// Copy contents that are not arrays
flattenedArray.push(arr[i]);
}
}
return flattenedArray;
};
steamrollArray([1, [2], [3, [[4]]]])
console.log(steamrollArray([1, [2], [3, [[4]]]]))

++++++++++++++++++++++++++++++

binary agent

function binaryAgent(str) {
let array = str.split(’ ‘);
array = array.map(item=>{return String.fromCharCode(parseInt(item,2));});
return array.join(’');
}
++++++++++++++++++++++++++++++++++++++

Everything Be True

function truthCheck(collection, pre) {
//console.log(collection[2][pre])
//console.log(collection.map(item => item[pre]))
return collection.map(item => item[pre]).every(item => Boolean(item))
}

++++++++++++++++++++++++++++++++++++++++++

Arguments Optional

function addTogether() {
let arr = […arguments];
console.log(arr);
if(arr.some(elem => typeof(elem) !==‘number’)) {
return undefined;
}
else if (arr.length == 1) {
return function addTwo(y) {
console.log(y)
return addTogether(arr[0],y);
}
}
else {return arr[0] + arr[1]}
}

addTogether(23)(4);
//console.log(typeof(3))

function addTogether() {
  let arr = [...arguments];
  console.log(arr);
  if(arr.some(elem => typeof(elem) !=='number')) {
    return undefined;
  }
  else if (arr.length == 1) {
    return function addTwo(y) {
      console.log(y)
      return addTogether(arr[0],y);
    }
  }
  else {return arr[0] + arr[1]}
}

addTogether(23);
//console.log(typeof(3))
console.log(addTogether(23))


## Make a Person

## Map the Debris

```
  //let a = arr.map(elem => elem.avgAlt);
  function orbitalPeriod(arr) {
  const GM = 398600.4418;
  const earthRadius = 6367.4447;
  return arr.map(({ name, avgAlt }) => {
    const earth = earthRadius + avgAlt;
    const orbitalPeriod = Math.round(2 * Math.PI * Math.sqrt(Math.pow(earth, 3)/GM));
    return { name, orbitalPeriod };
  });
}
+++++++++++++++++++++++++++++++
## Wherefore art thou


function whatIsInAName(collection, source) {
  // "What's in a name? that which we call a rose
  // By any other name would smell as sweet.”
  // -- by William Shakespeare, Romeo and Juliet
  const souceKeys = Object.keys(source);

  // filter the collection
  return collection.filter(obj => {
    for (let i = 0; i < souceKeys.length; i++) {
      if (!obj.hasOwnProperty(souceKeys[i]) ||
          obj[souceKeys[i]] !== source[souceKeys[i]]) {
        return false;
      }
    }
    return true;
  });
}
```

## Pig Latin

```
function translatePigLatin(str) {
  let consonantRegex = /^[^aeiou]+/;
  let myConsonants = str.match(consonantRegex);
  return myConsonants !== null
    ? str
        .replace(consonantRegex, "")
        .concat(myConsonants)
        .concat("ay")
    : str.concat("way");

}

translatePigLatin("consonant");
```

## Sum All Odd Fibonacci Numbers

```
function sumFibs(num) {
  let arr=[];
  for (let i=0; i<100; i++) {
    if (i<2) {
      arr.push(1)
    }
    else {
      arr.push(arr[i-1]+arr[i-2])
    }
  }
  console.log(arr);
  //return arr;

let x = arr.filter(elem => elem % 2 ===1 && elem <= num)
let y = x.reduce((a, b) => (a+b));
return y;

}

sumFibs(14);

~~~~~~~~~~~~~~~~~~~~~~~~~~~~

```
function sumFibs(num) {
  let prevNumber = 0;
  let currNumber = 1;
  let result = 0;
  while (currNumber <= num) {
    if (currNumber % 2 !== 0) {
      result += currNumber;
    }
    currNumber += prevNumber;
    prevNumber = currNumber - prevNumber;
  }

  return result;
}

// test here
sumFibs(4);
```

## Sum All Primes

```
function sumPrimes(num) {
  // Helper function to check primality
  function isPrime(num) {
    for (let i = 2; i <= Math.sqrt(num); i++) {
      if (num % i == 0)
        return false;
    }
    return true;
  }

  // Check all numbers for primality
  let sum = 0;
  for (let i = 2; i <= num; i++) {
    if (isPrime(i))
      sum += i;
  }
  return sum;
}

## Palindrome Checker ```

```
function palindrome(str) {
  let newStr = str.replace(/\W|_/g,'').toLowerCase();
  let len = newStr.length;
  let leftPart;
  let rightPart;
  if (len % 2 == 0 ) {
     leftPart = newStr.slice(0, len/2);
     rightPart = newStr.slice(len/2, len);
  }
  else {
     leftPart = newStr.slice(0, len/2+1);
     rightPart = newStr.slice(len/2, len);
  }
  console.log(leftPart);
  console.log(rightPart);
  let arr=[];
  for (let i=rightPart.length-1; i>=0; i--) {
    arr.push(rightPart[i]);
  }
  let transRightPart = arr.join('');
  //console.log(transRightPart);
  //console.log(leftPart);
  return transRightPart == leftPart
  ? true
  : false
}

palindrome("eyye");


console.log("以下不看")

let a = "A man, a plan, a canal. Panama";
let b = a.replace(/\W/g,'').toLowerCase();
console.log(b);
let len =b.length;
console.log(len);
let cl=b.slice(0,10);
console.log(cl)
let cr=b.slice(11.5,21)
console.log(cr);
let arr=[];
for (let i=cr.length-1; i>=0; i--) {
  arr.push(cr[i]);
}
let fr=arr.join('');

console.log('fffffff')
console.log(fr)
console.log(cl)

console.log("_eye".replace(/\W|_/g,'').toLowerCase())

```

```

## Caesars Cipher

```
function rot13(str) {
  let obj = {
    A: 'N',
    B: 'O',
    C: 'P',
    D: 'Q',
    E: 'R',
    F: 'S',
    G: 'T',
    H: 'U',
    I: 'V',
    J: 'W',
    K: 'X',
    L: 'Y',
    M: 'Z',
    N: 'A',
    O: 'B',
    P: 'C',
    Q: 'D',
    R: 'E',
    S: 'F',
    T: 'G',
    U: 'H',
    V: 'I',
    W: 'J',
    X: 'K',
    Y: 'L',
    Z: 'M',
    ' ': ' ',
    '?': '?',
    '.': '.',
    '!': '!'
  }
  let arr = str.split('');
  console.log(arr)
  let arrCode = arr.map(elem => obj[elem]);
  //console.log(arrCode)
  console.log(arrCode.join(''))
  return (arrCode.join(''))
}

rot13("GUR DHVPX OEBJA SBK WHZCF BIRE GUR YNML QBT.");

## Telephone Number Validator

function telephoneCheck(str) {
  let regex0 = /^[0-9]{10}$/;
  console.log(regex0.test(str));
  let regex1 = /^[0-9]{3}(-|\s)[0-9]{3}(-|\s)[0-9]{4}/;
  console.log(regex1.test("2(757)622-7382"));

  let regex2 = /^1\s[0-9]{3}(-|\s)[0-9]{3}(-|\s)[0-9]{4}/;
  console.log(regex2.test(str));

  let regex3 = /^1\s\([0-9]{3}\)(-|\s)[0-9]{3}(-|\s)[0-9]{4}/;
  console.log(regex3.test((str)));

  let regex4 = /^1\([0-9]{3}\)[0-9]{3}-[0-9]{4}/;
  console.log(regex4.test((str)));

  let regex5 = /^\([0-9]{3}\)[0-9]{3}-[0-9]{4}/;
  console.log(regex5.test(('2(757)622-7382')));

console.log((regex5.test(str) || regex4.test(str) || regex3.test(str) || regex0.test(str) || regex1.test(str) || regex2.test(str)))
  if (regex5.test(str) || regex4.test(str) || regex3.test(str) || regex0.test(str) || regex1.test(str) || regex2.test(str)) {
    return true;
  }
  return false;
}

telephoneCheck("2(757)622-7382");
//console.log(telephoneCheck("2(757)622-7382"));
``

```

## Profile Lookup

```
function lookUpProfile(name, prop) {
  // Only change code below this line
  //console.log(contacts[0].firstName)
  let names = contacts.map(elem => elem.firstName)
  console.log(names)
  let ind= names.indexOf(name);
  console.log(ind);
  if (ind >= 0) {
    let p = contacts[ind];
    console.log(contacts[ind]);
    if (p.hasOwnProperty(prop)) {
      return p[prop];
    }
    else { return 'No such property'};
  }
  else {return 'No such contact'};
  // Only change code above this line
}

//lookUpProfile("Akira", "likes");
console.log(lookUpProfile("Akira", "likes"))
```
++++++++++++++++++++++++++++++++++++++

## Roman Numeral Converter

```
function convertToRoman(num) {
  let obj = {
    1000: 'M',
    900: 'CM',
    500: 'D',
    400: 'CD',
    100: 'C',
    90: 'XC',
    50: 'L',
    40: 'XL',
    10: 'X',
    9: 'IX',
    5: 'V',
    4: 'IV',
    1: 'I'
  }
  //console.log(obj[num])
  //return obj[num];

  console.log(num.toString().split(''));
  let arrStr = num.toString().split('');
  let arrNum = arrStr.map(elem => parseInt(elem));
  console.log(arrNum);
  let len = arrNum.length;

  let p1 = "";
  let p2 = "";
  let p3 = "";
  let p4 = "";

  if (arrNum[len-1]<=3) {
    p1 = 'I'.repeat(arrNum[len-1])
  }
  else if (arrNum[len-1]<=8 && arrNum[len-1]>=6) {
    p1 = "V".concat('I'.repeat(arrNum[len-1]-5));
      console.log(p1);
  }
  else {p1 = obj[arrNum[len-1]]; console.log(p1)}
    

  if(len>=2) {
    if(arrNum[len-2]<=3) {
      p2 = 'X'.repeat(arrNum[len-2])
    }
    else if (arrNum[len-2]<=8 && arrNum[len-2]>=6) {
      p2 = "L".concat('X'.repeat(arrNum[len-2]-5));
      //console.log(p1);
    }
    else {p2 = obj[arrNum[len-2]*10]; console.log(p2)}
  }


  if(len>=3) {
    if(arrNum[len-3]<=3) {
      p3 = 'C'.repeat(arrNum[len-3])
    }
    else if (arrNum[len-3]<=8 && arrNum[len-3]>=6) {
      p3 = "D".concat('C'.repeat(arrNum[len-3]-5));
      //console.log(p1);
    }
    else {p3 = obj[arrNum[len-3]*100]; console.log(p3)}
  }

    if(len>=4) {
      p4 = 'M'.repeat(arrNum[len-4]);
      //console.log(p4)
      //return p3[0]
    }

  return (p4+p3+p2+p1);
} 


convertToRoman(400)

```~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

```
function convertToRoman(num) {
  let obj = {
  M:	1000,
  CM:	900,
  D:	500,
  CD:	400,
  C:	100,
  XC:	90,
  L:	50,
  XL:	40,
  X:	10,
  IX:	9,
  V:	5,
  IV:	4,
  I:	1
  }

  let answer = "";
  for (let prop in obj) {
    //console.log(prop)
    //console.log(obj[prop])
    while (num>=obj[prop]) {
      answer = answer+prop;
      num -= obj[prop];
      console.log(answer)
      //console.log(num)
    }
    //console.log(answer)
  }
  return answer;

}

convertToRoman(9);
console.log(convertToRoman(999));



```