2017年校招全国统一模拟笔试(第三场)编程题集合

地址:2017年校招全国统一模拟笔试(第三场)编程题集合

变换次数 (AC)

牛牛想对一个数做若干次变换,直到这个数只剩下一位数字。
变换的规则是:将这个数变成 所有位数上的数字的乘积。比如285经过一次变换后转化成285=80.
问题是,要做多少次变换,使得这个数变成个位数。
输入描述:
输入一个整数。小于等于2,000,000,000。

输出描述:
输出一个整数,表示变换次数。

输入例子1:

285

输出例子1:

2

var readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.on('line', function(line) {
  var times = 0;
  var str = line.trim();
  calc(str);
  console.log(times);
  function calc(str){
    if(str.length === 1){
      return times;
    } else {
      times++;
      calc(str.split('').map(Number).reduce(function(a, b){
        return a * b;
      }, 1) + '');
    }
  }
});

神奇数 (AC)

给出一个区间[a, b],计算区间内“神奇数”的个数。
神奇数的定义:存在不同位置的两个数位,组成一个两位数(且不含前导0),且这个两位数为质数。
比如:153,可以使用数字3和数字1组成13,13是质数,满足神奇数。同样153可以找到31和53也为质数,只要找到一个质数即满足神奇数。
输入描述:
输入为两个整数a和b,代表[a, b]区间 (1 ≤ a ≤ b ≤ 10000)。

输出描述:
输出为一个整数,表示区间内满足条件的整数个数

输入例子1:

11 20

输出例子1:

6

var readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.on('line', function(line) {
  var num = line.trim().split(' ').map(Number);
  var count = 0;
  for(var i = num[0]; i <= num[1]; i++){
    if(isMagicNum(i)){
      count++;
    }
  }
  console.log(count);

  function isMagicNum(num){
    arr = ('' + num).split('');
    var len = arr.length;
    for(var i = 0; i < arr.length; i++){
      for(var j = 0; j < arr.length; j++){
        if(i !== j && arr[j] !== '0' && arr[i] !== '0'){
          if(isPrime(parseInt(arr[i] + arr[j]))){
            return true;
          } else if(isPrime(parseInt(arr[j] + arr[i]))){
            return true;
          }
        }
      }
    }
    return false;
  }

  function isPrime(num){
    if((num & 1) === 0) return num === 2;
    var limit = Math.sqrt(num);
    for(var i = 3; i <= limit; i += 2){
      if(num % i === 0) return false;
    }
    return true;
  }

});

添加字符 (AC)

牛牛手里有一个字符串A,羊羊的手里有一个字符串B,B的长度大于等于A,所以牛牛想把A串变得和B串一样长,这样羊羊就愿意和牛牛一起玩了。
而且A的长度增加到和B串一样长的时候,对应的每一位相等的越多,羊羊就越喜欢。比如"abc"和"abd"对应相等的位数为2,为前两位。
牛牛可以在A的开头或者结尾添加任意字符,使得长度和B一样。现在问牛牛对A串添加完字符之后,不相等的位数最少有多少位?
输入描述:
第一行为字符串A,第二行为字符串B,A的场地小于等于B的长度,B的长度小于等于50.字符均为小写字母。

输出描述:
输出一个整数表示A串添加完字符之后,不相等的位数最少有多少位?

输入例子1:

abe
cabc

输出例子1:

1

var readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
var currLine = 0;
var strA, strB;
rl.on('line', function(line) {
  if(currLine === 0){
    strA = line.trim();
    currLine++;
  } else {
    strB = line.trim();
    if(strA.length === strB.length){
      console.log(getDiffLen(strA, strB));
    } else {
      console.log(strA.length - maxCommonSubStrLen(strA, strB))
    }
    currLine = 0, strA = strB = '';
  }

  function maxCommonSubStrLen(a, b){
    var maxLen = 0, len = 0;
    var lenA = a.length, lenB = b.length;
    var temp;
    for(var i = 0; i < lenB - lenA + 1; i++){
      temp = b.slice(i, i + lenA);
      len = getCommonLen(a, temp);
      maxLen = len < maxLen ? maxLen : len;
    }
    return maxLen;
  }
  function getDiffLen(a, b){
    if(a.length !== b.length) throw new Error('Two parameters in "getDiffLen" should be same length.');
    var arrA = a.split('');
    var arrB = b.split('');
    var num = 0;
    arrA.forEach(function(item, index){
      if(item !== arrB[index]){
        num++;
      }
    });
    return num;
  }
  function getCommonLen(a, b){
    if(a.length !== b.length) throw new Error('Two parameters in "getDiffLen" should be same length.');
    return a.length - getDiffLen(a, b);
  }
});

数组变换 (AC)

牛牛有一个数组,里面的数可能不相等,现在他想把数组变为:所有的数都相等。问是否可行。
牛牛可以进行的操作是:将数组中的任意一个数改为这个数的两倍。
这个操作的使用次数不限,也可以不使用,并且可以对同一个位置使用多次。

输入描述:
输入一个正整数N (N <= 50)
接下来一行输入N个正整数,每个数均小于等于1e9.

输出描述:
假如经过若干次操作可以使得N个数都相等,那么输出"YES", 否则输出"NO"

输入例子1:

2
1 2

输出例子1:

YES

var readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
var currLine = 0;
var len, nums;
rl.on('line', function(line) {
  if(currLine === 0){
    len = parseInt(line);
    currLine++;
  } else {
    nums = line.trim().split(' ').map(Number);
    console.log(yesorno(nums));
    len = currLine = 0, nums = null;

    function yesorno(arr){
      var flag = null, temp;
      for(var i = 0; i < len; i++){
        temp = nums[i];
        while((temp & 1) === 0){
          temp /= 2;
        }
        if(flag){
          if(temp === flag) {
            continue;
          } else {
            return 'NO';
          }
        } else {
          flag = temp;
        }
      }
      return 'YES'
    }
  }
});

排序子序列 (AC)

牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这个数组分为几段排序子序列.
如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出2

输入描述:
输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)

第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字。

输出描述:
输出一个整数表示牛牛可以将A最少划分为多少段排序子序列

输入例子1:

6
1 2 3 2 2 1

输出例子1:

2

var readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
var currLine = 0;
var len, nums;
rl.on('line', function(line) {
  if(currLine === 0){
    len = parseInt(line);
    currLine++;
  } else {
    nums = line.trim().split(' ').map(Number);
    var count = 1;
    var isAsc = null;
    for(var i = 1, j = 0; i < len; i++){
      if(nums[i] < nums[i - 1]){
        if(isAsc === null) isAsc = true;
        else if(!isAsc) {
          count++;
          isAsc = null;
        }
      } else if(nums[i] > nums[i - 1]){
        if(isAsc === null) isAsc = false;
        else if(isAsc){
          count++;
          isAsc = null;
        }
      }
    }
    console.log(count);
    len = currLine = 0, nums = null;
  }
});

组队竞赛 (Memory out)

牛牛举办了一次编程比赛,参加比赛的有3*n个选手,每个选手都有一个水平值a_i.现在要将这些选手进行组队,一共组成n个队伍,即每个队伍3人.牛牛发现队伍的水平值等于该队伍队员中第二高水平值。
例如:
一个队伍三个队员的水平值分别是3,3,3.那么队伍的水平值是3
一个队伍三个队员的水平值分别是3,2,3.那么队伍的水平值是3
一个队伍三个队员的水平值分别是1,5,2.那么队伍的水平值是2
为了让比赛更有看点,牛牛想安排队伍使所有队伍的水平值总和最大。
如样例所示:
如果牛牛把6个队员划分到两个队伍
如果方案为:
team1:{1,2,5}, team2:{5,5,8}, 这时候水平值总和为7.
而如果方案为:
team1:{2,5,8}, team2:{1,5,5}, 这时候水平值总和为10.
没有比总和为10更大的方案,所以输出10.

输入描述:
输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)
第二行包括3*n个整数a_i(1 ≤ a_i ≤ 10^9),表示每个参赛选手的水平值.

输出描述:
输出一个整数表示所有队伍的水平值总和最大值.

输入例子1:

2
5 2 8 5 1 5

输出例子1:

10

var readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
var currLine = 0;
var group, nums;
rl.on('line', function(line) {
  if(currLine === 0){
    group = parseInt(line);
    currLine++;
  } else {
    nums = line.trim().split(' ').map(Number).sort(function(a, b){
      return b - a;
    });
    var len = nums.length;
    var ans = 0;
    for(var i = 1; i < len - group; i += 2){
      ans += nums[i];
    }
    console.log(ans);
    group = currLine = 0, nums = null;
  }
});

牛牛的数列 (AC)

牛牛现在有一个n个数组成的数列,牛牛现在想取一个连续的子序列,并且这个子序列还必须得满足:最多只改变一个数,就可以使得这个连续的子序列是一个严格上升的子序列,牛牛想知道这个连续子序列最长的长度是多少。
输入描述:
输入包括两行,第一行包括一个整数n(1 ≤ n ≤ 10^5),即数列的长度;
第二行n个整数a_i, 表示数列中的每个数(1 ≤ a_i ≤ 10^9),以空格分割。

输出描述:
输出一个整数,表示最长的长度。

输入例子1:

6
7 2 3 1 5 6

输出例子1:

5

var readline = require('readline');
var quantity = 0, len = 0;
var max = 0, temp = 0, flag = 0;
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
var currLine = 0;
var len, nums;
rl.on('line', function(line) {
  if(currLine === 0){
    len = parseInt(line);
    currLine++;
  } else {
    nums = line.trim().split(' ').map(Number);
    var ans = 1;
    var pre = [0], post = [0];

    nums.shift(Infinity);
    nums.push(Infinity);
    for(var i = 1; i <= len; i++){
      pre[i] = nums[i - 1] < nums[i] ? pre[i - 1] + 1 : 1;
    }
    for(var i = len; i > 0; i--){
      post[i] = nums[i] < nums[i + 1] ? post[i+1] + 1 : 1;
    }

    for (var i = 1; i <= len; i++){
      if (nums[i + 1] - nums[i - 1] >= 2) ans = Math.max(ans, pre[i - 1] + post[i + 1] + 1);
    }
    console.log(ans);
    len = currLine = 0, nums = null;
  }
});

训练部队 (AC)

小牛牛是牛牛王国的将军,为了训练出精锐的部队,他会对新兵进行训练。部队进入了n个新兵,每个新兵有一个战斗力值和潜力值,当两个新兵进行决斗时,总是战斗力值高的获胜。获胜的新兵的战斗力值就会变成对手的潜力值 + 自己的战斗力值 - 对手的战斗力值。败者将会被淘汰。若两者战斗力值一样,则会同归于尽,双双被淘汰(除了考察的那个新兵之外,其他新兵之间不会发生战斗) 。小牛牛想知道通过互相决斗之后新兵中战斗力值+潜力值最高的一个可能达到多少,你能帮助小牛牛将军求出来吗?

输入描述:
输入包括n+1行,第一行包括一个整数n(1 ≤ n ≤ 10^5);
接下来的n行,每行两个整数x和y(1 ≤ x,y ≤ 10^9)

输出描述:
输出一个整数,表示新兵中战斗力值+潜力值最高的一个能达到多少。

示例输入

2
1 2
2 1

示例输出

4

var readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
var quantity = 0, len = 0;
var sum = 0, temp = 0, flag = 0;
rl.on('line', function(line) {
  if(quantity === 0){
    quantity = len = parseInt(line);
  } else {
    var input = line.trim().split(' ').map(Number);
    if(input[0] >= input[1]){
      temp = input[0] + input[1];
      flag = flag > temp ? flag : temp;
    } else {
      temp = 2 * input[0];
      flag = flag > temp ? flag : temp;
      sum += input[1] - input[0];
    }
    quantity--;
    if(quantity === 0){
      console.log(sum + flag);
    }
  }
});

推荐阅读更多精彩内容