FreeCodeCamp基础算法脚本 Basic Alogrithm Scripting

Convert Celsius to Fahrenheit

将摄氏度转换为华氏度的算法为:摄氏度 × 9/5 + 32

输入参数 celsius代表一个摄氏温度值。请你根据上述转换公式,将已定义好的 fahrenheit变量赋值为对应的华氏温度的值。
你不需要顾虑 function 和 return 语句,它们会在之后的挑战中予以介绍。现在,你只需要使用你已学过的运算符

function convertToF(celsius) {
  let fahrenheit;
  fahrenheit=celsius*9/5+32
  return fahrenheit;
}

convertToF(30);

Reverse a String

翻转字符串

先把字符串转化成数组,再借助数组的reverse方法翻转数组顺序,最后把数组转化成字符串。
你的结果必须得是一个字符串

function factorialize(num) {
  // 请把你的代码写在这里
  if(num==0){
    return 1
  }
 var sum=1;
  for(let i=1;i<=num;i++){
    sum=sum*i;
  }
   return sum;
}
factorialize(5);

Factorialize a Number

计算一个整数的阶乘

如果用字母n来代表一个整数,阶乘代表着所有小于或等于n的整数的乘积。
阶乘通常简写成 n!

例如: 5! = 1 * 2 * 3 * 4 * 5 = 120

方法一

function factorialize(num) {
  // 请把你的代码写在这里
 var sum=1;
  for(i=1;i<=num;i++){
    sum=sum*i;
  }
   return sum;
}
factorialize(5);

方法二(递归)

function factorialize(num) {
  var result;
  if(num<0){
    result=-1;
  }else if(num===0||num===1){
    result=1;
  }else if(num>1){
    result=num*factorialize(num-1);
  }
  return result;
}
factorialize(5);

Check for Palindromes

检查回文字符串

如果给定的字符串是回文,返回true,反之,返回false。
如果一个字符串忽略标点符号、大小写和空格,正着读和反着读一模一样,那么这个字符串就是palindrome(回文)
注意你需要去掉字符串多余的标点符号和空格,然后把字符串转化成小写来验证此字符串是否为回文。
函数参数的值可以为"racecar","RaceCar"和"race CAR"。

function palindrome(str) {
    // 请把你的代码写在这里
    var reg=/(\W|-|_)/g;
    var strNew=str.replace(reg,'').toLowerCase()
    var strNewReverse=strNew.split('').reverse().join('')
    console.log(strNew)
    console.log(strNewReverse)
    return strNew===strNewReverse;
}
console.log(palindrome("race car"));

Find the Longest Word in a String

返回所提供的最长的单词句子的长度。
你应该返回一个数字

function findLongestWordLength(str) {
    let max=0
    let array =str.split(' ')
    console.log(array);
    for(let item of array){
        console.log(item);
        if(max<item.length){
            max=item.length
        }
    }
    return max;
}
console.log(findLongestWordLength("The quick brown fox jumped over the lazy dog"));

Return Largest Numbers in Arrays

找出多个数组中的最大数

右边大数组中包含了4个小数组,分别找到每个小数组中的最大值,然后把它们串联起来,形成一个新数组。
提示:你可以用for循环来迭代数组,并通过arr[i]的方式来访问数组的每个元素。

function largestOfFour(arr) {
    // 请把你的代码写在这里
    var arrNew=[]
    for(var i=0;i<arr.length;i++){
        arrNew.push(arr[i].sort(function(a,b){return b-a}).shift())
    }
    return arrNew;
}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

Confirm the Ending

检查字符串结尾

判断一个字符串(str)是否以指定的字符串(target)结尾。
如果是,返回true;如果不是,返回false。

function confirmEnding(str, target) {
  // 请把你的代码写在这里
  var lens=target.length
  return str.substr(-lens)===target?true:false
}

confirmEnding("Bastian", "n");

Repeat a string repeat a string

重复输出字符串

(重要的事情说3遍)

重复一个指定的字符串 num次,如果num是一个负数则返回一个空字符串。

function repeatStringNumTimes(str, num) {
  // 请把你的代码写在这里
  var strNew=str
  if(num>0){
  for(var i=1;i<num;i++){
    strNew=strNew.concat(str)
  }
  return strNew;
  }
else{
  return ''
  }
}

repeatStringNumTimes("abc", 3);

Truncate a string

截断字符串

如果字符串的长度比指定的参数num长,则把多余的部分用...来表示。
切记,插入到字符串尾部的三个点号也会计入字符串的长度。
但是,如果指定的参数num小于或等于3,则添加的三个点号不会计入字符串的长度。

function truncate(str, num) {
  if (str.length > num)
    return str.slice(0, num > 3 ? num-3 : num) + '...';
  return str;
}

truncate("A-tisket a-tasket A green and yellow basket", 11);

Finders Keepers

发现者与看护者

请写一个函数来检查一个数组(第一个参数)中的元素,并返回数组中第一个通过校验测试(第二个参数,一个接受一个参数并返回一个布尔值的函数)的元素。如果没有元素通过测试,则返回 undefined。

function findElement(arr, func) {
  let num = 0;
  //遍历数组,如果数组中的其中一个元素作为参数传入的函数符合测试,就返回这个值
  for(let i of arr){
  if(func(i))
  return i
  }
}

findElement([1, 2, 3, 4], num => num % 2 === 0);

Boo who

真假测试

检查一个值是否是原始的布尔值(boolean)类型。返回 true 或者 false。
布尔值原始类型为 true 或者 false。
如果你有任何疑问,可以访问 Read-Search-Ask 。你可以与他人结对编程。请你独立解决挑战中的问题。

function booWho(bool) {
  return typeof bool === "boolean";
}

// test here
booWho(null);

Title Case a Sentence

单词的首字母大写

将给出的字符串中所有单词的第一个字母变成大写,并返回得到的字符串。请确保其余的字母是小写的。
出于练习的目的,“ the ”“ of ”等虚词的首字母也要大写。
如果你有任何疑问,可以访问 Read-Search-Ask 。请你独立解决挑战中的问题。

function titleCase(str) {
  const arr=str.split(' ')  //["I'm","a","little","tea", "pot"]
  return arr.map(val=>{ 
  //map 纯函数,不改变原数组,
  //每个字符串都变小写,然后将每个字符串的第一个字母变成大写
  val=val.toLowerCase() 
  return val.toLowerCase().replace(val.charAt(0),val.charAt(0).toUpperCase())
}).join(' ')
}

titleCase("I'm a little tea pot");

Slice and Splice

slice 和 splice

本挑战的输入参数为:两个数组和一个索引值。
请利用数组的 slice和 splice方法,将第一个数组中的所有元素依次复制到第二个数组中。
请从第二个数组中索引值为 n的地方开始插入。
返回插入元素后的数组。输入的两个数组在函数执行前后要保持不变。

function frankenSplice(arr1, arr2, n) {
  // It's alive. It's alive!
  let localArray = arr2.slice();
  for (let i = 0; i < arr1.length; i++) {
    localArray.splice(n, 0, arr1[i]);
    n++;
  }
  return localArray;
}

改变原数组

function frankenSplice(arr1, arr2, n) {
  // It's alive. It's alive!
  arr2.splice(n,0,...arr1)
  return arr2;
}

frankenSplice([1, 2, 3], [4, 5, 6], 1);

方案2 但还是有一个

 function frankenSplice(arr1, arr2, n) {
    // It's alive. It's alive!
    let arr=[]
    for(let i=0;i<arr2.length;i++){
        if(i===n){
            arr=arr.concat(arr1).concat(arr2[i])
            console.log('xrr')
            console.log(arr)
        }else if(i!==n){
            arr=arr.concat(arr2[i])
            console.log('arr')
            console.log(arr)
        }

    }



    console.log(1)
    console.log(arr)
    console.log(arr2);
    return arr;
}

frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"],2)

Not PassedFalsy Bouncer

去除数组中的假值

从一个数组中移除所有假值(falsy values)。
JavaScript 中的假值有 false、null、0、""、undefined和 NaN。
提示:请尝试将每一个值转换为一个布尔值(boolean)

function bouncer(arr) {
  // Don't show a false ID to this bouncer.
return arr.filter((value, index, arr)=>{
  console.log(value,index,arr)
  return Boolean(value)==true
  }) 
}
bouncer([7, "ate", "", false, 9]);

Chunky Monkey

猴子吃香蕉, 分割数组

(猴子吃香蕉可是掰成好几段来吃哦)

把一个数组arr按照指定的数组大小size分割成若干个数组块。

例如:chunk([1,2,3,4],2)=[[1,2],[3,4]];

chunk([1,2,3,4,5],2)=[[1,2],[3,4],[5]];

function chunk(arr, size) {
  // 请把你的代码写在这里
  var arrNew=[]
  var arrChunk=[]
  for(var i=0;i<arr.length/size;i++){
    arrNew=arr.slice(i*size,(i+1)*size)
    arrChunk.push(arrNew)
  }
  
 return arrChunk
}

chunk(["a", "b", "c", "d"], 2);

Slasher Flick

截断数组

返回一个数组被截断n个元素后还剩余的元素,截断从索引0开始。


function slasher(arr, howMany) {
  // 请把你的代码写在这里
 arr.splice(0,howMany);
  return arr
}

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

Mutations

集合之间的关系

(蛤蟆可以吃队友,也可以吃对手)
如果数组第一个字符串元素包含了第二个字符串元素的所有字符,函数返回true。
举例,["hello", "Hello"]应该返回true,因为在忽略大小写的情况下,第二个字符串的所有字符都可以在第一个字符串找到。
["hello", "hey"]应该返回false,因为字符串"hello"并不包含字符"y"。
["Alien", "line"]应该返回true,因为"line"中所有字符都可以在"Alien"找到。

function mutation(arr) {
  // 请把你的代码写在这里
  var flag=0
  var strOne=arr[0].toLowerCase()
  var strTwo=arr[1].toLowerCase()
  for(let i=0;i<strTwo.length;i++){
    if(strOne.includes(strTwo[i])===true){
      flag++;
    }else{
      flag=0
    }
  }
  if(flag===strTwo.length){
    return true
  }else{
    return false
  }
}

mutation(["hello", "neo"]);

Falsy Bouncer

过滤数组假值

删除数组中的所有假值。
在JavaScript中,假值有false、null、0、""、undefined 和 NaN。

function bouncer(arr) {
  // 请把你的代码写在这里
  return arr.filter(function(e){
    return Boolean(e)!==false
  })
}

bouncer([false, null, 0, NaN, undefined, ""]);

Seek and Destroy

摧毁数组

实现一个摧毁(destroyer)函数,第一个参数是待摧毁的数组,其余的参数是待摧毁的值。

function destroyer(arr) {
  // 请把你的代码写在这里
//   console.log(arguments.length)
  var arrDestroy=[]
    for(var i=1;i<arguments.length;i++){
    arrDestroy.push(arguments[i])
    }
  console.log(arrDestroy)
return arguments[0].filter(function(e){
    return arrDestroy.includes(e)===false    
})
  
}
destroyer([3, 5, 1, 2, 2], 2, 3, 5);

Where do I belong

数组排序并找出元素索引

我身在何处?
先给数组排序,然后找到指定的值在数组的位置,最后返回位置对应的索引。
举例:where([1,2,3,4], 1.5) 应该返回 1。因为1.5插入到数组[1,2,3,4]后变成[1,1.5,2,3,4],而1.5对应的索引值就是1。
同理,where([20,3,5], 19) 应该返回 2。因为数组会先排序为 [3,5,20],19插入到数组[3,5,20]后变成[3,5,19,20],而19对应的索引值就是2。

function where(arr, num) {
  // 请把你的代码写在这里
  var arr=arr.sort(function(a,b){
    return a-b
  })
  for(var i=0;i<arr.length;i++){
    if(num<=arr[i]){
       return i
    }
  }
  return i

}

where([5, 3, 20, 3], 5);

Caesars Cipher

凯撒密码

(让上帝的归上帝,凯撒的归凯撒)
下面我们来介绍风靡全球的凯撒密码Caesar cipher,又叫移位密码。
移位密码也就是密码中的字母会按照指定的数量来做移位。
一个常见的案例就是ROT13密码,字母会移位13个位置。由'A' ↔ 'N', 'B' ↔ 'O',以此类推。
写一个ROT13函数,实现输入加密字符串,输出解密字符串。
所有的字母都是大写,不要转化任何非字母形式的字符(例如:空格,标点符号),遇到这些特殊字符,跳过它们。

function rot13(str) { // LBH QVQ VG!
                      // 请把你的代码写在这里
    var arr=str.split('')
    var strNew=""
    console.log(arr)
    for(var i=0;i<arr.length;i++){
           var num=arr[i].charCodeAt()
            console.log(num)
            if(num>=65&&num<=77){
                num=num+13
            }else if(num>77&&num<=90){
                num=(num-78)+65
            }else{
                num=num
            }
        strNew=strNew.concat(String.fromCharCode(num))
    }
    return strNew
}

rot13("SERR PBQR PNZC");