笔试编程题

比眉伴天荒 2022-05-17 23:43 182阅读 0赞

## 1.题目描述 ##

头条的2017校招开始了！为了这次校招，我们组织了一个规模宏大的出题团队，每个出题人都出了一些有趣的题目，而我们现在想把这些题目组合成若干场考试出来，在选题之前，我们对题目进行了盲审，并定出了每道题的难度系统。一场考试包含3道开放性题目，假设他们的难度从小到大分别为a,b,c，我们希望这3道题能满足下列条件：  
a<=b<=c  
b-a<=10  
c-b<=10  
所有出题人一共出了n道开放性题目。现在我们想把这n道题分布到若干场考试中（1场或多场，每道题都必须使用且只能用一次），然而由于上述条件的限制，可能有一些考试没法凑够3道题，因此出题人就需要多出一些适当难度的题目来让每场考试都达到要求，然而我们出题已经出得很累了，你能计算出我们最少还需要再出几道题吗？

## 输入描述: ##

输入的第一行包含一个整数n，表示目前已经出好的题目数量。

第二行给出每道题目的难度系数d1,d2,...,dn。

数据范围

对于30%的数据，1 ≤ n,di ≤ 5;

对于100%的数据，1 ≤ n ≤ 10^5,1 ≤ di ≤ 100。

在样例中，一种可行的方案是添加2个难度分别为20和50的题目，这样可以组合成两场考试：（20 20 23）和（35,40,50）。

## 输出描述: ##

输出只包括一行，即所求的答案。

**示例1**

## 输入 ##

20 35 23 40

## 输出 ##

链接：[https://www.nowcoder.com/questionTerminal/57cf0b1050834901933e9b48daafbb9a][https_www.nowcoder.com_questionTerminal_57cf0b1050834901933e9b48daafbb9a]  
来源：牛客网  
  
var n=readline();  
var m=readline();  
var arr= m.split(' ').sort(sortNumber);  
function sortNumber(a,b)\{  
return a-b;  
\};  
var i=0;  
var k=0;  
var n1,n2,n3;  
while(i<arr.length)\{  
n1=arr\[i\];  
n2=arr\[i+1\];  
if(n2)\{  
if(n2-n1>20)\{  
k+=2;  
i++;  
\}else if(n2-n1>10&&n2-n1<=20)\{  
k+=1;  
i+=2;  
\}else\{  
n3=arr\[i+2\];  
if(n3)\{  
if(n3-n2>10)\{  
k+=1;  
i+=2;  
\}  
else\{  
i+=3;  
\}  
\}  
else\{  
k+=1;  
i+=2;  
\}  
\}  
\}  
else\{  
k+=2;  
i+=2;  
\} 吧  
\}  
console.log(k);

2.\[编程题\]字符串中找出连续最长的数字串

读入一个字符串str，输出字符串str中的连续最长的数字串

输入描述:

个测试输入包含1个测试用例，一个字符串str，长度不超过255。

输出描述:

在一行内输出str中里连续最长的数字串。

示例1

## 输入 ##

abcd12345ed125ss123456789

## 输出 ##

123456789

链接：[https://www.nowcoder.com/questionTerminal/bd891093881d4ddf9e56e7cc8416562d][https_www.nowcoder.com_questionTerminal_bd891093881d4ddf9e56e7cc8416562d]  
来源：牛客网

`var` `readline = require('readline');`

`const rl = readline.createInterface({`

`input: process.stdin,`

`output: process.stdout`

`});`

`rl.on('line', function(line1){`

`//``以字母切割数组`

`var` `arr=line1.trim().split(/[a-zA-Z]+/);`

`var` `max=0;`

`var` `str;`

`for(var` `i=0;i<arr.length;i++){`

`//``切割的数组中不能包含空格，纯数字`

`if(arr[i].length>max&&arr[i].indexOf(" ")===-1){`

`max=arr[i].length;`

`str=arr[i];`

`}`

`console.log(str);`

`});`

3.\[编程题\]回文字符串

*  热度指数：15028 时间限制：1秒 空间限制：65536K

给出一个长度不超过1000的字符串，判断它是不是回文(顺读，逆读均相同)的。

输入描述:

输入包括一行字符串，其长度不超过1000。

输出描述:

可能有多组测试数据，对于每组数据，如果是回文字符串则输出"Yes!”，否则输出"No!"。

示例1

## 输入 ##

hellolleh

helloworld

## 输出 ##

Yes!

No!

链接：[https://www.nowcoder.com/questionTerminal/df00c27320b24278b9c25f6bb1e2f3b8][https_www.nowcoder.com_questionTerminal_df00c27320b24278b9c25f6bb1e2f3b8]  
来源：牛客网

`var` `readline = require('readline');`

`var` `rl = readline.createInterface({`

`input: process.stdin,`

`output: process.stdout`

`});`

`function` `hui(s){`

`if(s.length<=1)return` `"Yes!";`

`if(s[0]===s[s.length-1]) return` `hui(s.slice(1,s.length-1));`

`else` `return` `"No!";`

`}`

`rl.on('line', function(input) {`

`console.log( hui(input));`

`});`

链接：[https://www.nowcoder.com/questionTerminal/df00c27320b24278b9c25f6bb1e2f3b8][https_www.nowcoder.com_questionTerminal_df00c27320b24278b9c25f6bb1e2f3b8]  
来源：牛客网

`var` `readline = require('readline');`

`const rl = readline.createInterface({`

`input: process.stdin,`

`output: process.stdout`

`});`

`rl.on('line', function(line){`

`var` `str = line.trim();`

`for(var` `i=0;i<Math.ceil(str.length/2);i++)`

`{`

`if(str[i]!=str[str.length-1-i])`

`{`

`console.log("No!");`

`break;`

`}`

`else{`

`if(i==Math.ceil(str.length/2)-1)`

`{`

`console.log("Yes!");`

`}`

`});`

链接：[https://www.nowcoder.com/questionTerminal/df00c27320b24278b9c25f6bb1e2f3b8][https_www.nowcoder.com_questionTerminal_df00c27320b24278b9c25f6bb1e2f3b8]  
来源：牛客网

var readline = require('readline');

var rl = readline.createInterface(\{

input: process.stdin,

output: process.stdout

\});

function isPalindrome(str) \{

str += "";

for(var i=0,j=str.length-1;i<j;i++,j--)\{

if(str.charAt(i) !== str.charAt(j))\{

return "No!";

return "Yes!";

rl.on('line', function(input) \{

console.log( isPalindrome(input));

\});

1.  二叉排序数

## 题目描述 ##

输入一系列整数，建立二叉排序数，并进行前序，中序，后序遍历。

## 输入描述: ##

输入第一行包括一个整数n(1<=n<=100)。

接下来的一行包括n个整数。

## 输出描述: ##

可能有多组测试数据，对于每组数据，将题目所给数据建立一个二叉排序树，并对二叉排序树进行前序、中序和后序遍历。

每种遍历结果输出一行。每行最后一个数据之后有一个空格。

输入中可能有重复元素，但是输出的二叉树遍历序列中重复元素不用输出。

**示例1**

## 输入 ##

1 6 5 9 8

## 输出 ##

1 6 5 9 8

1 5 6 8 9

5 8 9 6 1

链接：[https://www.nowcoder.com/questionTerminal/b42cfd38923c4b72bde19b795e78bcb3][https_www.nowcoder.com_questionTerminal_b42cfd38923c4b72bde19b795e78bcb3]  
来源：牛客网

`var` `readline = require('readline');`

`var` `rl = readline.createInterface({`

`input: process.stdin,`

`output: process.stdout`

`});`

`var` `n = -1`

`var` `inputArr = [];`

`rl.on('line', function` `(input) {`

`if(n===-1){`

`n = input`

`}`

`else{`

`inputArr = input.split(' ')`

`n = -1`

`var` `tree = new` `BST()`

`var` `arr = []`

`inputArr.forEach(function(v){`

`//``取到的是字符串，需要转为数字，不然后面大小比较会出错`

`v = v - 0`

`if(arr.indexOf(v)===-1){`

`arr.push(v)`

`tree.insert(new` `Node(v, null, null))`

`}`

`})`

`tree.print1()`

`tree.print2()`

`tree.print3()`

`}`

`})`

`function` `Node(key, left, right){`

`this.key = key`

`this.left = left`

`this.right = right`

`}`

`function` `BST(){`

`this.root = null`

`}`

`BST.prototype.insert = function(node){`

`if(this.root == null){`

`this.root = node`

`}else{`

`var` `current = this.root`

`while(true){`

`if(node.key < current.key){`

`if(current.left == null){`

`current.left = node`

`break;`

`}else{`

`current = current.left`

`}`

`else{`

`if(current.right == null){`

`current.right = node`

`break`

`}else{`

`current = current.right`

`}`

`BST.prototype.print1 = function(){`

`var` `arr = []`

`function` `printNode(node){`

`if(node != null){`

`arr.push(node.key)`

`printNode(node.left)`

`printNode(node.right)`

`}`

`printNode(this.root)`

`console.log(arr.join(' ') + ' ')`

`}`

`BST.prototype.print2 = function(){`

`var` `arr = []`

`function` `printNode(node){`

`if(node != null){`

`printNode(node.left)`

`arr.push(node.key)`

`printNode(node.right)`

`}`

`printNode(this.root)`

`console.log(arr.join(' ') + ' ')`

`}`

`BST.prototype.print3 = function(){`

`var` `arr = []`

`function` `printNode(node){`

`if(node != null){`

`printNode(node.left)`

`printNode(node.right)`

`arr.push(node.key)`

`}`

`printNode(this.root)`

`console.log(arr.join(' ') + ' ')`

`}`

## 5.方阵 题目描述 ##

输入一个N（N<=10）阶方阵，按照如下方式调整方阵： 1.将第一列中最大数所在的行与第一行对调。 2.将第二列中从第二行到第N行最大数所在的行与第二行对调。 依此类推... N-1.将第N-1列中从第N-1行到第N行最大数所在的行与第N-1行对调。 N.输出这个方阵

## 输入描述: ##

包含多组测试数据,每组测试数据第一行为一个整数N,表示方阵的阶数.

接下来输入这个N阶方阵.

## 输出描述: ##

调整后的方阵

**示例1**

## 输入 ##

3 6 8 7

6 7 5 3

8 6 5 3

9 8 7 2

## 输出 ##

9 8 7 2

6 7 5 3

3 6 8 7

8 6 5 3

链接：[https://www.nowcoder.com/questionTerminal/053875842995497e937ac58f65cddfae][https_www.nowcoder.com_questionTerminal_053875842995497e937ac58f65cddfae]  
来源：牛客网

`#include <iostream>`

`using` `namespace` `std;`

`int` `main() {`

`int` `N;`

`while` `(cin >> N) {`

`int` `arr[N][N], IndexMax[N], index, temp[N]; //``每一列最大值标记``IndexMax[N],``最大值所在行数，用于置换的``temp`

`for` `(int` `i = 0; i < N; i++)`

`for` `(int` `j = 0; j < N; j++)`

`cin >> arr[i][j];`

`for` `(int` `j = 0; j < N; j++) { //``从列到行循环`

`IndexMax[j] = arr[j][j]; //``先假定``j``列的``j``行为最大值，并记录行号``index = j`

`index = j;`

`for` `(int` `i = j; i < N; i++) //``行号由``j``开始到最大值结束`

`if` `(arr[i][j] > IndexMax[j]) { //``查找最大值，先进行标记操作`

`IndexMax[j] = arr[i][j];`

`index = i;`

`}`

`for` `(int` `k = 0; k < N; k++) { //``循环完后，第``j``行与``index``行相互交换`

`temp[k] = arr[index][k];`

`arr[index][k] = arr[j][k];`

`arr[j][k] = temp[k];`

`}`

`for` `(int` `i = 0; i < N; i++) { //``打印转置以后的数组`

`for` `(int` `j = 0; j < N; j++) {`

`cout << arr[i][j];`

`if` `(j != N - 1) //``若不为结尾打印空格以分隔`

`cout << " ";`

`}`

`cout << endl;`

`}`

链接：[https://www.nowcoder.com/questionTerminal/053875842995497e937ac58f65cddfae][https_www.nowcoder.com_questionTerminal_053875842995497e937ac58f65cddfae]  
来源：牛客网

`#include<stdio.h>`

`int` `main()`

`{`

`int` `N;`

`int` `i,j;`

`int` `max;`

`while(scanf("%d",&N)!=EOF)`

`{`

`int` `a[10][10]={0};`

`for(i=0;i<N;i++) /**``录入数据``*/`

`for(j=0;j<N;j++)`

`scanf("%d",&a[i][j]);`

`for(j=0;j<N;j++)`

`{`

`max=j;`

`for(i=j;i<N;i++) /**``寻找第``j``列第``i``到``N-1``行中最大值的行数``*/`

`{`

`if(a[i][j]>a[max][j])`

`max=i;`

`}`

`if(max!=j) /**``交换``max``行与第``j``行``*/`

`{`

`int` `k,t[10];`

`for(k=0;k<N;k++)`

`t[k]=a[max][k];`

`for(k=0;k<N;k++)`

`a[max][k]=a[j][k];`

`for(k=0;k<N;k++)`

`a[j][k]=t[k];`

`}`

`for(i=0;i<N;i++) /**``输出``*/`

`{`

`for(j=0;j<N;j++)`

`{`

`if(j==0) printf("%d",a[i][j]);`

`else` `printf(" %d",a[i][j]);`

`}`

`printf("\n");`

`}`

`return` `0;`

`}`

## 6.题目描述 ##

给定一个n\*n的矩阵，求该矩阵的k次幂，即P^k。

## 输入描述: ##

第一行：两个整数n（2<=n<=10）、k（1<=k<=5），两个数字之间用一个空格隔开，含义如上所示。

接下来有n行，每行n个正整数，其中，第i行第j个整数表示矩阵中第i行第j列的矩阵元素Pij且（0<=Pij<=10）。另外，数据保证最后结果不会超过10^8。

## 输出描述: ##

对于每组测试数据，输出其结果。格式为：

n行n列个整数，每行数之间用空格隔开，注意，每行最后一个数后面不应该有多余的空格。

**示例1**

## 输入 ##

2 2

9 8

9 3

## 输出 ##

153 96

108 81

链接：[https://www.nowcoder.com/questionTerminal/31e539ab08f949a8bece2a7503e9319a][https_www.nowcoder.com_questionTerminal_31e539ab08f949a8bece2a7503e9319a]  
来源：牛客网

`#include<stdio.h>`

`int` `main(){`

`int` `n,k;`

`while(scanf("%d%d",&n,&k)!=EOF){`

`int` `num[10][10];`

`int` `tmp1[10][10];`

`int` `ans[10][10];`

`for(int` `i=0;i<n;i++) for(int` `j=0;j<n;j++){`

`Int tmp; scanf("%d",&tmp); num[i][j] =tmp; ans[i][j]=tmp; tmp1[i][j]=tmp; } while(k>1){`

`for(int` `i=0;i<n;i++)`

`for(int` `j=0;j<n;j++){`

`int` `tmp=0;`

`for(int` `x=0;x<n;x++){`

`tmp+=tmp1[i][x]*num[x][j];`

`}`

`ans[i][j]=tmp;`

`}`

`for(int` `i=0;i<n;i++) for(int` `j=0;j<n;j++) tmp1[i][j]=ans[i][j];`

`k--;`

`}`

`for(int` `i=0;i<n;i++){`

`for(int` `j=0;j<n;j++){ if(j==n-1) printf("%d",ans[i][j]); else` `printf("%d ",ans[i][j]);`

`}`

`printf("\n");`

`}`

链接：[https://www.nowcoder.com/questionTerminal/31e539ab08f949a8bece2a7503e9319a][https_www.nowcoder.com_questionTerminal_31e539ab08f949a8bece2a7503e9319a]  
来源：牛客网

`#include<stdio.h>`

`void` `Mi(int` `d[10][10],int` `data[10][10],int` `n,int` `k)`

`{`

`int` `i,j,r,t,num;`

`int` `str[10][10];`

`for(i=0;i<n;i++)`

`for(j=0;j<n;j++)`

`{`

`str[i][j]=d[i][j];`

`data[i][j]=d[i][j];`

`}`

`for(t=1;t<k;t++) /**``计算``k``次幂``*/`

`{`

`for(i=0;i<n;i++)`

`{`

`for(j=0;j<n;j++)`

`{`

`num=0;`

`for(r=0;r<n;r++)`

`num+=str[i][r]*d[r][j]; /**data[i][j]``等于``str``第``i``行和``d``第``j``列的乘积``*/`

`data[i][j]=num;`

`}`

`for(i=0;i<n;i++)`

`for(j=0;j<n;j++)`

`str[i][j]=data[i][j];`

`}`

`return` `;`

`}`

`int` `main()`

`{`

`int` `T;`

`int` `n,k;`

`int` `i,j,r;`

`while(scanf("%d",&T)!=EOF)`

`{`

`int` `d[10][10]={0};`

`int` `data[10][10]={0};`

`for(r=0;r<T;r++) /**``有``T``组矩阵``*/`

`{`

`scanf("%d %d",&n,&k);`

`for(i=0;i<n;i++) /**``为矩阵赋值``*/`

`for(j=0;j<n;j++)`

`scanf("%d",&d[i][j]);`

`Mi(d,data,n,k); /**``计算``d``的``k``次幂，结果用``data[][]``存储``*/`

`for(i=0;i<n;i++) /**``输出运算结果``*/`

`{`

`for(j=0;j<n;j++)`

`{`

`if(j==0) printf("%d",data[i][j]);`

`else` `printf(" %d",data[i][j]);`

`}`

`printf("\n");`

`}`

`return` `0;`

`}`

[https_www.nowcoder.com_questionTerminal_57cf0b1050834901933e9b48daafbb9a]: https://www.nowcoder.com/questionTerminal/57cf0b1050834901933e9b48daafbb9a
[https_www.nowcoder.com_questionTerminal_bd891093881d4ddf9e56e7cc8416562d]: https://www.nowcoder.com/questionTerminal/bd891093881d4ddf9e56e7cc8416562d
[https_www.nowcoder.com_questionTerminal_df00c27320b24278b9c25f6bb1e2f3b8]: https://www.nowcoder.com/questionTerminal/df00c27320b24278b9c25f6bb1e2f3b8
[https_www.nowcoder.com_questionTerminal_b42cfd38923c4b72bde19b795e78bcb3]: https://www.nowcoder.com/questionTerminal/b42cfd38923c4b72bde19b795e78bcb3
[https_www.nowcoder.com_questionTerminal_053875842995497e937ac58f65cddfae]: https://www.nowcoder.com/questionTerminal/053875842995497e937ac58f65cddfae
[https_www.nowcoder.com_questionTerminal_31e539ab08f949a8bece2a7503e9319a]: https://www.nowcoder.com/questionTerminal/31e539ab08f949a8bece2a7503e9319a