网易2017秋招编程题集合_以下代码全部来自牛客网

首页 > 代码库 > 网易2017秋招编程题集合_以下代码全部来自牛客网

网易2017秋招编程题集合_以下代码全部来自牛客网

2024-11-25 14:19:01 203人阅读

如果一个数字序列逆置之后跟原序列是一样的就称这样的数字序列为回文序列。例如：
{1, 2, 1}, {15, 78, 78, 15} , {112} 是回文序列,
{1, 2, 2}, {15, 78, 87, 51} ,{112, 2, 11} 不是回文序列。
现在给出一个数字序列，允许使用一种转换操作：
选择任意两个相邻的数，然后从序列移除这两个数，并用这两个数字的和插入到这两个数之前的位置(只插入一个和)。
现在对于所给序列要求出最少需要多少次操作可以将其变成回文序列。

链接：https://www.nowcoder.com/questionTerminal/0147cbd790724bc9ae0b779aaf7c5b50
来源：牛客网

package com.suda.alex;
 
import java.util.ArrayList;
import java.util.Scanner;
 
public class Test1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            int[] item = new int[n];
            for(int i=0;i<n;i++){
                item[i] = scanner.nextInt();
            }
            System.out.println(leastTimeToHuiwen(n, item));
        }
    }
    public static int leastTimeToHuiwen(int n, int[] item) {
        //比较第一个和最后一个数，如果第一个大，则前两个相加替换原来位置。
        //如果最后一个数大，则最后两个相加替换原来位置。
        //如果首尾元素相等，则删除首尾元素。
        int leastTime = 0;
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int i=0;i<n;i++){
            list.add(item[i]);
        }
        while(list.size() > 1){
            if(list.get(0) < list.get(list.size() - 1)){
                int a = list.get(0);
                int b = list.get(1);
                list.set(0, a+b);
                list.remove(1);
                leastTime++;
            }
            else if(list.get(0) > list.get(list.size() - 1)){
                int a = list.get(list.size() - 1);
                int b = list.get(list.size() - 2);
                list.set(list.size() - 2, a+b);
                list.remove(list.size() - 1);
                leastTime++;
            }
            else{
                list.remove(0);
                list.remove(list.size() - 1);
            }
        }
        return leastTime;
    }
     
}

小易有一个圆心在坐标原点的圆，小易知道圆的半径的平方。小易认为在圆上的点而且横纵坐标都是整数的点是优雅的，小易现在想寻找一个算法计算出优雅的点的个数，请你来帮帮他。
例如：半径的平方如果为25
优雅的点就有：(+/-3, +/-4), (+/-4, +/-3), (0, +/-5) (+/-5, 0)，一共12个点。

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int rSquare = in.nextInt();
        int count =0;
        double r = Math.sqrt(rSquare);
 
        //存储值
        for(int i=0;i<r;i++){
            /*运行超时
            for(int j=1;j<r+1;j++){
                if(i*i+j*j==rSquare){
                    count++;
                }
            }
            */
//优化点1
            double j = Math.sqrt(rSquare-i*i);
            if((int) j==j){
                count++;
            }
        }
         
        //优化点2
        System.out.print(count<<2);
         
    }
}

小易来到了一条石板路前，每块石板上从1挨着编号为：1、2、3.......
这条石板路要根据特殊的规则才能前进：对于小易当前所在的编号为K的石板，小易单次只能往前跳K的一个约数(不含1和K)步，即跳到K+X(X为K的一个非1和本身的约数)的位置。小易当前处在编号为N的石板，他想跳到编号恰好为M的石板去，小易想知道最少需要跳跃几次可以到达。
例如：
N = 4，M = 24：
4->6->8->12->18->24
于是小易最少需要跳跃5次，就可以从4号石板跳到24号石板

/*思路 从m 到n 至少需要多少步
* mark[i]记录到达位置i的最少步数。初始化mark[],起始位置mark[m]为0外，其它位置都为无穷大
* i~[m,n-2]依次更新mark[]:
* 判断，如果mark[i]为无穷大，则说明该位置不可由m到达，那么该位置也就到不了n。跳过，不作处理。减枝。
* 如果mark[i]不是无穷大，计算i的因子，对每一个因子求出i的下一步的位置tmp，如果mark[tmp]>mark[i]+1，更新mark[tmp]=mark[i]+1;
* 最终结果是mark[n],如果mark[n]是无穷大，则输出-1；否则返回mark[n]。
*/
/*
* 比如以8开始 mark[8]=0,8的因子list={2,4},
* factor=2,可到达10,mark[10]原本是无穷大,现在更新mark[10]=mark[8]+1;12同理。
* 循环下一个i=9，mark[9]是无穷大，跳过，不用处理。
* 也就是由8产生10和12，接下来就处理10,12及其产生的位置，而无需处理其他。
*/
import java.util.Scanner;
import java.util.ArrayList;
import java.lang.Math;
public class Main{
    public static int deal(int m,int n){//m到n
        int mark[]=new int[n+1];//记录到达每一个位置的步数
        for(int i=0;i<=n;i++){                          //初始化
            mark[i]=Integer.MAX_VALUE;
        }
        mark[m]=0;                                      //初始化
        for(int i=m;i<n-1;i++){                         //填mark[]
                if(mark[i]==Integer.MAX_VALUE)continue; //如果当前起始位置本身不可达 不作处理
                ArrayList<Integer> list=allFactor(i);   //获得当前位置i的所有因子
                for(int j=0;j<list.size();j++){         //计算i能到达的每一个位置tmp
                    int tmp=i+list.get(j);
                    int count=mark[i]+1;
                    if(tmp<=n&&mark[tmp]>count){        //如果从i到达位置tmp的次数比以前记录的小 更新mark[tmp]
                        mark[tmp]=count;
                    }
                }          
        }
        return mark[n];
    }
    public static ArrayList<Integer>  allFactor(int n){//获得n的所有因子 除1 n外
        ArrayList list=new ArrayList();
        for(int i=2;i<=Math.sqrt(n);i++){
            if(n%i==0){
                list.add(i);
                if(i!=n/i)list.add(n/i);
            }
        }
        return list;
    }
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
         int m=sc.nextInt();
         int n=sc.nextInt();
         int r=deal(m,n);
         if(r==Integer.MAX_VALUE)r=-1;
         System.out.println(r);
        }  
}

一个只包含‘A‘、‘B‘和‘C‘的字符串，如果存在某一段长度为3的连续子串中恰好‘A‘、‘B‘和‘C‘各有一个，那么这个字符串就是纯净的，否则这个字符串就是暗黑的。例如：
BAACAACCBAAA 连续子串"CBA"中包含了‘A‘,‘B‘,‘C‘各一个，所以是纯净的字符串
AABBCCAABB 不存在一个长度为3的连续子串包含‘A‘,‘B‘,‘C‘,所以是暗黑的字符串
你的任务就是计算出长度为n的字符串(只包含‘A‘、‘B‘和‘C‘)，有多少个是暗黑的字符串

技术分享

#include <iostream>
using namespace std;
int main(){
    int n = 0;
    while(cin >> n){
        long long dp[31] = {0};
        dp[1] = 3, dp[2] = 9;
        for( int i = 3; i <= n; i++ )
            dp[i] = 2*dp[i-1]+dp[i-2];
        cout<<dp[n]<<endl;
    }  
}

对于一个整数X，定义操作rev(X)为将X按数位翻转过来，并且去除掉前导0。例如:
如果 X = 123，则rev(X) = 321;
如果 X = 100，则rev(X) = 1.
现在给出整数x和y,要求rev(rev(x) + rev(y))为多少？

// 很简单
import java.util.Scanner;
public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        int out = rev(rev(m)+rev(n));
        System.out.println(out);
             
    }
    public static int rev(int num){
        int x = 0;
        while(num!=0){
            x = 10*x + num%10;
            num = num/10;
        }
        return x;
    }
}

小易是一个数论爱好者，并且对于一个数的奇数约数十分感兴趣。一天小易遇到这样一个问题：定义函数f(x)为x最大的奇数约数，x为正整数。例如:f(44) = 11.
现在给出一个N，需要求出 f(1) + f(2) + f(3).......f(N)
例如： N = 7
f(1) + f(2) + f(3) + f(4) + f(5) + f(6) + f(7) = 1 + 1 + 3 + 1 + 5 + 3 + 7 = 21
小易计算这个问题遇到了困难，需要你来设计一个算法帮助他。

//找规律，你会发现基数都是直接取，偶数/2，得到的基础直接取，偶数继续/2，每次循环，可以把规模缩小1/2。
//要注意的是((i + 1) / 2) * ((i + 1) / 2)运算时候，括号的优先级。
 
#include "iostream"
 
using namespace std;
typedef long long LL;
 
int main()
{
    LL N;
    LL Ans = 0;
    while (cin >> N)
    {
        Ans = 0;
        for (LL i = N; i > 0; i = i / 2)
            Ans += ((i + 1) / 2) * ((i + 1) / 2);
        cout << Ans << endl;
    }
    return 0;
}

小易去附近的商店买苹果，奸诈的商贩使用了捆绑交易，只提供6个每袋和8个每袋的包装(包装不可拆分)。可是小易现在只想购买恰好n个苹果，小易想购买尽量少的袋数方便携带。如果不能购买恰好n个苹果，小易将不会购买。

//复杂度O(1)方法
import java.util.*;
public class Main{
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        while(in.hasNextInt()){
            int n = in.nextInt();
            System.out.println(count(n));
        }
    }
    public static int count(int n){
        if(n%2!=0||n==10||n<6) return -1;//一定是偶数（6，8都是）,最小是6，10以上偶数都可以；
        if(n%8==0) return n/8;//如果拿八个拿完最好
        return 1+n/8;//对于10以上的偶数，只要对8取余数不为0，就要从前面的1或者2个8中拿出2个，把余数补为6（本来余数就是6，就不用拿）。所以+1；
    }
}

A,B,C三个人是好朋友,每个人手里都有一些糖果,我们不知道他们每个人手上具体有多少个糖果,但是我们知道以下的信息：
A - B, B - C, A + B, B + C. 这四个数值.每个字母代表每个人所拥有的糖果数.
现在需要通过这四个数值计算出每个人手里有多少个糖果,即A,B,C。这里保证最多只有一组整数A,B,C满足所有题设条件。

这道题目的实质是：判断三元一次方程组是否有解及求解。
把题目条件用方程式表示：
A-B=Y1;
B-C=Y2;
A+B=Y3;
B+C=Y4;

用消元法求解：
A=(Y1+Y3)/2;
B=(Y3-Y1)/2=(Y2+Y4)/2;
C=(Y4-Y2)/2;

由于题目给出的是整数，要求解也是整数，这个约束条件也需要注意下。
不满足约束条件就是没解，就可以输出NO了，满足所有的约束条件那就是有解。

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int y1,y2,y3,y4;
        float a,b,c;
        while (in.hasNextInt()) {
            y1 = in.nextInt();
            y2 = in.nextInt();
            y3 = in.nextInt();
            y4 = in.nextInt();
            a=(y1+y3)/2f;
            b=(y3-y1)/2f;
            c=(y4-y2)/2f;
            if((a-((y1+y3)/2))!=0){
                System.out.print("No");
                return ;
            }
            if((b-((y3-y1)/2)!=0)||(b!=((y2+y4)/2))){
                System.out.print("No");
                return ;
            }
            if((c-((y4-y2)/2))!=0){
                System.out.print("No");
            return ;
            }
            //满足所有的约束条件，输出解。
            System.out.print((int)a+" "+(int)b+" "+(int)c);
            }
    }
}

网易2017秋招编程题集合_以下代码全部来自牛客网

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > 网易2017秋招编程题集合_以下代码全部来自牛客网

网易2017秋招编程题集合_以下代码全部来自牛客网

看完仍有疑问？有类似问题直接问程序猿