赛码网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