在线OJ使用总结(acm)

赛码网OJ规则

用readLine()代替read_line()

用readLine()代替read_line()

用readLine()代替read_line()

用readLine()代替read_line()

用readLine()代替read_line()

// *项代表测试数据的时候固定不变的

var n = 0;  // *输入行计数：可以自动计算出行数
var input=['1 2','3 4']; //输入两行

// *模拟输入
function read_line(){
    var line = input[n];
    n++;
    return line;
}

 // *模拟输出
function print(x){
    console.log(x);
}

/////////////模拟a+b
(function(){
    var line;
    while(line = read_line()){
        line = line.split(' ');
        print(parseInt(line[0]) + parseInt(line[1]));
    }
})();
/////////////////////////////////////////////////////

多行数据处理

例如：当输入以下数据的时候：
3
1 1 1
9
1 5 -6 7 9 -16 0 -2 2
2
0 0
处理多行数据方法一：

var line;
var datas = [];
while(line = read_line()){
    line = line.split('
');  // 以行读取
    datas.push(line);
}
// print(datas) // 3,1 1 1,9,1 5 -6 7 9 -16 0 -2 2,2,0 0
while (datas.length) {
  var n = datas[0];
  var arr = datas[1].toString().split(' ');  // 最好toString()一下，强制为字符串哦~
  paper(n, arr);  // 具体的函数
  datas.shift(datas[0]);  // 重点：处理完成一组 弹出一组数据！
  datas.shift(datas[1]);  
}

var line;
var datas = [];
while(line = read_line()){
    line = line.split('
');  // 以行读取
    datas.push(line);
}
// print(datas) // 3,1 1 1,9,1 5 -6 7 9 -16 0 -2 2,2,0 0
while (datas.length) {
  var n = datas[0];
  var data = datas[1].toString().split(' ').map(function (item) {
    return parseInt(item);
  });

  print(n);
  print(data);
  print('====')
  
  //paper(n, arr);  // 具体的函数
  
  datas.shift(datas[0]);  // 重点：处理完成一组 弹出一组数据！
  datas.shift(datas[1]);  
}

处理多行数据方法二：
例如：对于已经分好块的数据
1 2
1
2 3
// 没有这个，为了理解方便加的注释
1 2
1
1 2

while(read_line()){  // 这里read_line()的意思是如果这一行有值，转换成布尔true
  var str1 = readLine().toString().split(' ');  // 这里用的是拼接函数
  var str2 = readLine().toString().split(' ');
  var str = str1.concat(str2);
  str = str.uniq().sort(cmp).join(' ');   // 自定义函数处理部分
  print(str);
}

例如：
对于没有分好块儿的数据，一般第一个数字是代表一共有几个数据块儿
所以我们先把第一个数据块儿提取出来，再像前面已经分好块儿那样做即可
2 // 代表两个数据块儿
1 2
1
2 3
// 没有这个，为了理解方便加的注释
1 2
1
1 2

var line = read_line();
while(line){
  var str1 = readLine().toString().split(' ');  // 这里用的是拼接函数
  var str2 = readLine().toString().split(' ');
  var str = str1.concat(str2);
  str = str.uniq().sort(cmp).join(' ');   // 自定义函数处理部分

  line --; // 处理一组数据总数据数目减一
  print(str);
}

js编程常用方法总结

1.join():数组->字符串，自动会加上逗号
2.split()：字符串->数组，
3.strim()：去除首尾空格
4.如果是单个数字，加上一层parseInt(),强制转换为整型
5.初始化的时候指定类型，
eg:
var num = 0; // Number
var arr = []; // 数组
6. 涉及到单个数字，或者数字的四则运算一定要parseInt
7. 清空上一组数据
8. 常见Math方法
9. num.toFixed(1)

其他常用方法：

var max = Math.max.apply(Math,arr); // arr为已知数组
toLocalUpperCase() // 转为大写字母

join()：
用于把数组中的所有元素放入一个字符串。
元素是通过指定的分隔符进行分隔的。

split():
方法用于把一个字符串分割成字符串数组。
stringObject.split(separator,howmany)
separator必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。
howmany可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

var str="How are you doing today?"

document.write(str.split(" ") + "<br />")  // How,are,you,doing,today?
document.write(str.split("") + "<br />")  // H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?
document.write(str.split(" ",3))  // How,are,you

"2:3:4:5".split(":")	//将返回["2", "3", "4", "5"]
"|a|b|c".split("|")	//将返回["", "a", "b", "c"]
"hello".split("")	//可返回 ["h", "e", "l", "l", "o"]
"hello".split("", 3)	//可返回 ["h", "e", "l"]

输入：
3
1 2 3 4

// split('/n')读取后：
['3','1 2 3 4'];

小Tips

1.看清楚输入输出的格式
2.如果是大数据没有通过，很可能是read_line()读取除了问题，建议自己写一个拼接函数

pop():删除数组的最后一个元素，减少数组的长度，返回删除的值。

push(n):将参数加载到数组的最后，返回新数组的长度。

shift():删除数组的第一个元素,数组长度减1，返回删除的值。

unshift(n1,n2):把参数加载数组的前面，返回新数组的长度。

sort()：按指定的参数对数组进行排序 ，返回的值是经过排序之后的数组

reverse()：反转数组项的顺序，返回的值是经过排序之后的数组

concat(3,4)：把两个数组拼接起来。 返回的值是一个副本

slice[start,end)：返回从原数组中指定开始下标到结束下标之间的项组成的新数组（不影响原数组）
1个参数：n.即：n到末尾的所有
2个参数：[start,end]

splice()：
删除：2个参数，起始位置，删除的项数
插入：3个参数，起始位置，删除的项数，插入的项
替换：任意参数，起始位置，删除的项数，插入任意数量的项

链接：http://www.cnblogs.com/Yfling/p/6680159.html
indexOf()和lastIndexOf()：接受两个参数，要查找的项(可选)和查找起点位置的索引
indexOf()：从数组开头向后查找
lastIndexOf()：从数组末尾开始向前查找

every()：对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true。
filter()：对数组中的每一项运行给定函数，返回该函数会返回true的项组成数组。
forEach()：对数组的每一项运行给定函数，这个方法没有返回值。
map()：对数组的每一项运行给定函数，返回每次函数调用的结果组成的数组。
some()：对数组的每一项运行给定参数，如果该函数对任一项返回true，则返回true。以上方法都不会修改数组中的包含的值。
reduce()和reduceRight()：缩小数组的方法，这两个方法都会迭代数组的所有项，然后构建一个最终返回的值。
join(separator)：将数组的元素组起一个字符串，以separator为分隔符，省略的话则用默认用逗号为分隔符

常用函数：

// parseInt转换为数组函数，数据格式必须如下面data所示
var data = '1 2 3 4 5 6';

var toArray = function(data) {
  var arr = [];
  var str = data.slice(0).split(' ');
  for (var i = 0; i < str.length; i++) {
    arr.push(parseInt(str[i]));
  }
  return arr;
}

//大数拼接
function readLine() {  // 核心：大数拼接问题
  var line = ""
  var next = read_line()
  while(next.length >= 1024) {
    line += next;
    next = read_line();
  }
  line += next;
  return line;
}

Array.prototype.uniq = function() {
    var res = [];
    var json = {};

    for (var i =0; i < this.length; i++) {
        if (!json[this[i]]) {
            res.push(this[i]);
            json[this[i]] = 1;
        }
    }
    return res;
}
////
var sum = readLine();
var data = readLine();
var res = [];
for (var i = 0; i < data.length; i++) {
  if (data[i] !== 'X' &&  data[i] !== '#') {
    var num = parseInt(data[i]);
    var start = (i - num) > 0 ? i - num : 0;
    var end = (i + num) < data.length ? i + num : data.length;

    for (var j = start; j <= end; j++) {
      if (data[j] === 'X') {
        res.push(j);
      }
    }
  }
}
print(res.uniq().length)

// 去重函数：
Array.prototype.uniq = function() {
    var res = [];
    var json = {};

    for (var i =0; i < this.length; i++) {
        if (!json[this[i]]) {
            res.push(this[i]);
            json[this[i]] = 1;
        }
    }
    return res;
}
2:利用正则
function unique(arr) {
    return arr.sort().join(",,").
    replace(/(,|^)([^,]+)(,,2)+(,|$)/g, "$1$2$4").
    replace(/,,+/g, ",").
    replace(/,$/, "").
    split(",")
}
3:ES6
var uniq = function(arr) {
    return Array.from(new Set(arr));
}
let uniq = [...new Set(arr)];  // arr是需要去重的数组
/////////////////////////////////////////////
// 比较函数
var cmp = function (a, b) {
    return a - b;
}
// 拼接函数
function readLine() {
  var line = ""
  var next = read_line()
  while(next.length >= 1024) {
    line += next;
    next = read_line();
  }
  line += next;
  return line;
}

//最大值
Math.max.apply(this, arr)

// 比较x与y是否相等
var equal = function(x, y) {
  var len1 = x.length;
  var len2 = y.length;
  if (len1 !== len2) return false;  // 不相等

  for (var i = 0; i < len1; i++) {
    if (x[i] === y[i]) continue;
    else {
      return false;
    }
  }
  return true;
}
// 任意数组的全排列
function permute(input) {
    var permArr = [],
    usedChars = [];
    function main(input){
        var i, ch;
        for (i = 0; i < input.length; i++) {
            ch = input.splice(i, 1)[0];
            usedChars.push(ch);
            if (input.length == 0) {
                permArr.push(usedChars.slice());
            }
            main(input);
            input.splice(i, 0, ch);
            usedChars.pop();
        }
        return permArr
    }
    return main(input);
};
console.log(permute([5, 3, 7, 1, 2]));

---

尚未总结：
根据某一属性排序：http://www.cnblogs.com/woodk/p/5535756.html
js按照两个条件排序：https://zhidao.baidu.com/question/1639668198909962740.html

// 判断两个对象是否相等
isequal = function(x, y) { 
  if ( x === y ) {
    return true;
  } 
  if ( ! ( x instanceof Object ) || ! ( y instanceof Object ) ) {
    return false;
  }
  if ( x.constructor !== y.constructor ) {
    return false;
  }
  for ( var p in x ) {
    if ( x.hasOwnProperty( p ) ) {
      if ( ! y.hasOwnProperty( p ) ) {
        return false;
      }
      if ( x[ p ] === y[ p ] ) {
        continue;
      }
      if ( typeof( x[ p ] ) !== "object" ) {
        return false;
      }
      if ( ! Object.equals( x[ p ], y[ p ] ) ) {
        return false;
      } 
    }
  }
  for ( p in y ) {
    if ( y.hasOwnProperty( p ) && ! x.hasOwnProperty( p ) ) {
      return false;
    }
  } 
  return true; 
};

objA={ 
 a:'123', 
 b:'000',
 c:'111'
}; 
objB={ 
 a:'123', 
 b:'000',
 c:'111'
}; 
var isEqual= isequal(objA, objB); 
console.log(isEqual);  // true

print(JSON.stringify(objB)==JSON.stringify(objB))

// 伪数组->数组
var arr = Array.prototype.slice.call(arguments)
var arr = Array.from(arguments);
// 判断一个数字是否是素数
function isPrime(num){
    // 不是数字或者数字小于2
    if(typeof num !== "number" || !Number.isInteger(num)){　　　　　　// Number.isInterget 判断是否为整数
        return false;
    }

    //2是质数
    if(num == 2){
        return true; 
    }else if(num % 2 == 0){  //排除偶数
        return false;
    }
    //依次判断是否能被奇数整除，最大循环为数值的开方
    var squareRoot = Math.sqrt(num);
    //因为2已经验证过，所以从3开始；且已经排除偶数，所以每次加2
    for(var i = 3; i <= squareRoot; i += 2) {
      if (num % i === 0) {
         return false;
      }
    }
    return true;
}
// 输出指定区间的素数
var prime = function(len){
    var i,j;
    var arr = [];
     
  for(i = 1; i < len; i++){
    for(j=2; j < i; j++){  
      if(i%j === 0) {
         break;
      }
    }
     
    if(i <= j && i !=1){
      arr.push(i);
    }
    
  }
  return arr;
};

ES6 新增字符串扩展

// for…of：
let str="wbiokr";
for(let s of str){
    console.log(s)
}
//结果：w, b, i, o, k, r

// 判断一个字符串中是否包含一个字符(ES6)
var str = "12345";
print(str.includes('1'))  // true

//判断字符串是否以某个字符开头/结束 (ES6)
print(str.includes('c'))  // false
print(str.startsWith('str'))  // true
print(str.endsWith('ng'))  // true

// 字符串复制
var str = 'mo';
print(str.repeat(2))  // momo