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

如果一个数字序列逆置之后跟原序列是一样的就称这样的数字序列为回文序列。例如：
{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);
            }
    }
}
时间： 2024-08-02 15:12:17

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

网易2017秋招编程题集合-牛客网

网易2017秋招编程题集合-牛客网 链接:https://www.nowcoder.com/questionTerminal/0147cbd790724bc9ae0b779aaf7c5b50来源:牛客网 如果一个数字序列逆置之后跟原序列是一样的就称这样的数字序列为回文序列.例如: {1, 2, 1}, {15, 78, 78, 15} , {112} 是回文序列, {1, 2, 2}, {15, 78, 87, 51} ,{112, 2, 11} 不是回文序列. 现在给出一个数字序列,允许使用一

网易2017秋招编程题——回文序列 解题报告

Problem:https://www.nowcoder.com/question/next?pid=2811407&qid=46573&tid=6015849 如果一个数字序列逆置之后跟原序列是一样的就称这样的数字序列为回文序列.例如: {1, 2, 1}, {15, 78, 78, 15} , {112} 是回文序列, {1, 2, 2}, {15, 78, 87, 51} ,{112, 2, 11} 不是回文序列. 现在给出一个数字序列,允许使用一种转换操作: 选择任意两个相邻的数,

网易2017春招[编程题]分饼干@Java

o6b19TK菜3孤Whttp://www.docin.com/app/user/userinfo?userid=178838282 eO白懊窒1瘫9肯3钠E山段http://huiyi.docin.com/hwhx2495 53k腾7懦95泛纤3Vhttp://tushu.docin.com/sina_5847498140 柑5v课9N1缴遮9毖Fhttp://www.docin.com/app/user/userinfo?userid=179253259 h3G伟t涝r焉布7R9http:/

算法是什么我记不住，But i do it my way. 解一道滴滴出行秋招编程题。

只因在今日头条刷到一篇文章,我就这样伤害我自己,手贱. 刷头条看到一篇文章写的滴滴出行2017秋招编程题,后来发现原文在这里http://www.cnblogs.com/SHERO-Vae/p/5882357.html.看了下,挺有意思,于是就想了想,又写了写,最终撸出来了.刚开始一看顿时感觉很熟悉,大学数据结构和算法课肯定讲过相关东西,什么深度搜索,广度搜索,最优路径,最优解...但是现在你让我说个一二三,我还就只记住几个名字,说不定名字都记错.我向来不喜欢死记东西,能查到的真的不想背下来,而

滴滴出行秋招编程题

算法是什么我记不住,But i do it my way. 解一道滴滴出行秋招编程题. 只因在今日头条刷到一篇文章,我就这样伤害我自己,手贱. 刷头条看到一篇文章写的滴滴出行2017秋招编程题,后来发现原文在这里http://www.cnblogs.com/SHERO-Vae/p/5882357.html.看了下,挺有意思,于是就想了想,又写了写,最终撸出来了.刚开始一看顿时感觉很熟悉,大学数据结构和算法课肯定讲过相关东西,什么深度搜索,广度搜索,最优路径,最优解...但是现在你让我说个一二三,

网易2017秋招笔试题3：最长公共子括号序列长度

[问题来源]网传的2017网易秋招笔试题 [问题描述] [算法思路] 下面的解题思路摘自  http://www.cnblogs.com/Atanisi/p/7500186.html 刚看到题我就想到暴力解,深搜出所有合法的括号序列,再依次比较公共子序列的长度,返回最长的.但是深搜一般和路径有关,这道题仅仅需要最大公共子序列的长度.而我们发现最大公共子序列的长度就是 s.size() - 1(当且仅当修改距离为 1 时 LCS 最大), 那么我们就想到,可以变换 s 中一个括号的位置,枚举所有的

网易2017秋招---优雅的点

做了这么多的编程题,其实我感觉题目只要找到思路 ,代码实现是非常容易的,因为程序语言不懂的地方可以百度, 而为一个题目找到思路却是没办法搜索的,除非题目是现成可以被搜索的 这个题目求解十分容易,用O(n2)的算法 进行遍历,找到非x,y轴上的的坐标点 就+=4  在x y轴就+=2 思考花了3分钟,编码2分钟,比较入门的题 package com.net163.question; import org.junit.Test; /** * Created by Administrator on 2

集合（京东2017秋招真题）

解答思路很简单,使用Python的set函数和sort函数就可以完成,但是做完之后有时候有错误 如图 明明使用了sort但没有排序 原来是因为读入之后数字是字符串格式,所以排序的时候15 就排在了 6的前面 使用 int 调整一遍列表中元素的类型就可以了 while 1:     (x,y)=(int(x) for x in raw_input().split())     ary1=raw_input().split()     ary2=raw_input().split()     ary

采购单（京东2017秋招真题）

本来也不算很难的一道题,但是总是只通过60% 或者 80% 一眼就看出思路,代码也不难的题就是不能全部通过也是神烦,应该是格式上的问题,也不算完全弄明白了,简单说说,作为一种经验. 思路:给价钱 和 每种物品的个数排序 最贵:最高价买最多的物品,累加 最低:最低价买最多的物品.累加 语句:list.count()    list.sort()    set(list)等 以下为正确的python语句 while 1:     r = raw_input()     if r != '':