整理下w3cschool上，编程挑战的算法

翻转字符串

先把字符串转化成数组，再借助数组的reverse方法翻转数组顺序，最后把数组转化成字符串。

你的结果必须得是一个字符串

 

/*function reverseString(str) {
  var arr=str.split("");
  arr.reverse();
  str=arr.join("");
return str;
}*/

function reverseString(str){
  var chars=new Array(100);//顺序栈
  var top=-1;//顶指针
  for(i=0;i<str.length;i++){
    chars[i]=str.charAt(i);//存数据
    top++;
  }
  str="";//清空字符串
  for(top;top>=0;top--){
    str+=chars[top];//取数据
  }
  return str;
}

reverseString("hello");

 

 

 

计算一个整数的阶乘

如果用字母n来代表一个整数，阶乘代表着所有小于或等于n的整数的乘积。

阶乘通常简写成 n!

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

function factorialize(num) {
  var temp=1;
  for (var i=1;i<=num;i++){
    temp*=i;
  }
  num=temp;
return num;
}

factorialize(5);

 

//使用递归
function factorialize(num) {
  if(num===1||num===0){
    return 1;
  }
return factorialize(num-1)*num;
}

 

 

 

如果给定的字符串是回文，返回true，反之，返回false。

如果一个字符串忽略标点符号、大小写和空格，正着读和反着读一模一样，那么这个字符串就是palindrome(回文)。

注意你需要去掉字符串多余的标点符号和空格，然后把字符串转化成小写来验证此字符串是否为回文。

函数参数的值可以为"racecar"，"RaceCar"和"race CAR"。

function palindrome(str) {
// Good luck!
//字符串倒排序
  
  //转换成小写字符串，同一大小写
  //正则表达式不懂
  var str1=str.toLowerCase();
  str1=str1.replace(/[\ |\~|\`|\!|\@|\#|\$|\%|\^|\&|\*|\(|\)|\-|\_|\+|\=|\||\\|\[|\]|\{|\}|\;|\:|\"|\'|\,|\<|\.|\>|\/|\?]/g,"");
  //分割成数组
  var arr=str1.split("");
  
  //数组倒排序
  arr.reverse();
  //转换字符串
  var str2=arr.join("");

//条件语句
  /*if(str1==str2){
return true;}
  else{return false;}*/
  return(str1==str2);
}



palindrome("eye");

 

 

 

找到提供的句子中最长的单词，并计算它的长度。

函数的返回值应该是一个数字。

function findLongestWord(str) {
var arr=str.split(" ");
var temp=0;
  for(i=0;i<arr.length;i++){
  var str1=arr[i];
  temp=temp>str1.length?temp:str1.length;
}
  return temp;
}

findLongestWord("The quick brown fox jumped over the lazy dog");

 

 

 

确保字符串的每个单词首字母都大写，其余部分小写。

像'the'和'of'这样的连接符同理。

function titleCase(str) {
var arr=str.split(" ");
var str1="";
  //遍历数组
for(i=0;i<arr.length;i++){
  //把每段字符串第一个字母大写
    var strTemp=arr[i];
    var strTiQu1=strTemp.slice(0,1);
    strTiQu1=strTiQu1.toUpperCase();
    var strTiQu2=strTemp.slice(1);
    strTiQu2=strTiQu2.toLowerCase();
    arr[i]=strTiQu1+strTiQu2;
}
 for(i=0;i<arr.length-1;i++){
   str1+=arr[i]+" ";
 } 
  var i=arr.length;
  str1+=arr[i-1];
  return str1;
}

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

 

 

 

右边大数组中包含了4个小数组，分别找到每个小数组中的最大值，然后把它们串联起来，形成一个新数组。

提示：你可以用for循环来迭代数组，并通过arr[i]的方式来访问数组的每个元素。

function largestOfFour(arr) {
// You can do this!
  for(var i=0;i<arr.length;i++){
    arr[i]=maxOfArr(arr[i]);
  }
return arr;
}
//计算单个数组最大值
function maxOfArr(arr) {
  var max=arr[0];
  for(var i=1;i<arr.length;i++){
    max=max>arr[i]?max:arr[i];
  }
  return max;
}

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

 

 

 

检查一个字符串(str)是否以指定的字符串(target)结尾。

如果是，返回true;如果不是，返回false。

function confirmEnding(str, target) {
// "Never give up and good luck will find you."
// -- Falcor
  //声明两个数组用于存储
  var arr1=[],arr2=[];
  //用for循环存储字符
  var i;
  for(i=0;i<str.length;i++){
    arr1[i]=str[i];
  }
  for(i=0;i<target.length;i++){
    arr2[i]=target[i];
  }
  //采用while循环倒序比较
  var j=arr1.length-1;
  i=arr2.length-1;
  while(i>=0){
    if(arr2[i]==arr1[j]){
      i--;
      j--;
    }
    else{
      str=false;
      break;
    }
    str=true;
  }
  
return str;
}

confirmEnding("Bastian", "n");

 

 

 

重要的事情说3遍！

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

function repeat(str, num) {
// repeat after me
  if(num<=0){
    str="";
  }
  else{
    var newstr="";
    for(i=0;i<num;i++){
      newstr+= str;
    }
    str=newstr;
  }
  
return str;
}

repeat("abc", 3);

 

 

 

截断一个字符串！

如果字符串的长度比指定的参数num长，则把多余的部分用...来表示。

切记，插入到字符串尾部的三个点号也会计入字符串的长度。

但是，如果指定的参数num小于或等于3，则添加的三个点号不会计入字符串的长度。

function truncate(str, num) {
// Clear out that junk in your trunk
  var arr=[];
  for(var i=0;i<str.length;i++){
    arr[i]=str[i];
  }
  //字符串的长度比指定的参数num短
  //直接输出
  if(str.length<=num){
    return str;
  }
  //否则以下代码
  var last="...";
  str="";
  if(num<=3){
    for(j=0;j<num;j++){
      str+=arr[j];
    }
    str+=last;
    console.log(str);
  }
  else{
    for(j=0;j<num-last.length;j++){
      str+=arr[j];
    }
    str+=last;
    console.log(str);
  }
  
  
return str;
}

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

 

 

 

把一个数组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) {
    // Break it up.
    var arrSave=[];
    var lengther=parseInt(arr.length/size);
    //var bl=arr.length/size>lengther?true:false;
    for(i=0;i<lengther;i++){
        arrSave[i]=element(arr,size);
        //print(arrSave);
    }
    if(arr.length!==0){
        //此处判断条件不知道怎么写
        //可以用length判断
        arrSave.push(arr);
    }
    return arrSave;
}

//此函数用于返回分割后的每一个数组
function element(arr,size){
    var newarr = [];
    for(j = 0;j < size;j++){
        //print("j="+j);
        newarr[j]=arr[0];
        arr.shift(arr[0]);
        //print(newarr);
    }
    return newarr;
}

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

 

学姐提供的参考代码

function chunk(arr,size){
var subArrLength=Math.ceil((arr.length)/size);//里面数组的个数
var newArr=[];
for(var i=0;i<subArrLength;i++){
var subArr=[];
for(var j=0;j<size;j++){
subArr.push(arr.shift());
if(arr.length===0){
break;
}
}
newArr.push(subArr);
}
return newArr;
}
var arr=[1,2,3,4,5];
console.log(chunk(arr,2));

 

 

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

function slasher(arr, howMany) {
// it doesn't always pay to be first
  if(howMany>=arr.length){
    arr=[];
  }
  else{
    var newArr=[],j=0;
    for(var i=howMany;i<arr.length;i++){
      newArr[j]=arr[i];
      j++;
    }
    arr=newArr;
  }
return arr;
}

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

 

 

 

如果数组第一个字符串元素包含了第二个字符串元素的所有字符，函数返回true。

举例，["hello", "Hello"]应该返回true，因为在忽略大小写的情况下，第二个字符串的所有字符都可以在第一个字符串找到。

["hello", "hey"]应该返回false，因为字符串"hello"并不包含字符"y"。

["Alien", "line"]应该返回true，因为"line"中所有字符都可以在"Alien"找到。

function mutation(arr) {
  //用两个字符串存储，并全都转换成小写
  var str1=arr[0],
      str2=arr[1];
  str1=str1.toLowerCase();
  str2=str2.toLowerCase();
  //print(str1+" ; "+str2);
  //用于返回的布尔值
  var bl=true;
  //循环遍历
  var i,j;
  for(i=0;i<str2.length;i++){
    for(j=0;j<str1.length;j++){
      if(str2[i]===str1[j]){
        //print(str2[i]+" * "+str1[j])
        break;
      }
      if(j===str1.length-1){
        bl=false;
      }
    }
  }
return bl;
}

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