网易2018实习生笔试编程题

最新推荐文章于 2024-06-21 15:49:55 发布

liqinzhe223

最新推荐文章于 2024-06-21 15:49:55 发布

阅读量1k

点赞数 1

分类专栏： leetcode

本文链接：https://blog.csdn.net/liqinzhe11/article/details/79729835

版权

leetcode 专栏收录该内容

280 篇文章 0 订阅

订阅专栏

牛牛的闹钟

时间限制：1秒

空间限制：32768K

牛牛总是睡过头，所以他定了很多闹钟，只有在闹钟响的时候他才会醒过来并且决定起不起床。从他起床算起他需要X分钟到达教室，上课时间为当天的A时B分，请问他最晚可以什么时间起床

输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含一个正整数，表示闹钟的数量N(N<=100)。
接下来的N行每行包含两个整数，表示这个闹钟响起的时间为Hi(0<=A<24)时Mi(0<=B<60)分。
接下来的一行包含一个整数，表示从起床算起他需要X(0<=X<=100)分钟到达教室。
接下来的一行包含两个整数，表示上课时间为A(0<=A<24)时B(0<=B<60)分。
数据保证至少有一个闹钟可以让牛牛及时到达教室。

输出描述:

输出两个整数表示牛牛最晚起床时间。

输入例子1:

输出例子1:

6 0

思路：难点可能就在自定义排序这上面了。

#include <iostream>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include<vector>
#include<map>
#include <set>
#include <queue>
#include <string>
#include <limits.h>
using namespace std;

class My_time
{
public:
    int hour;
    int minute;
    My_time(int c, int p) :hour(c), minute(p){}
};

bool cmp(const My_time& lhs, const My_time& rhs)
{
    if (lhs.hour == rhs.hour)
        return lhs.minute < rhs.minute;
    return lhs.hour < rhs.hour;
}

int main()
{
    int numOfClock;
    scanf("%d", &numOfClock);

    vector<My_time> times;
    for (int i = 0; i < numOfClock; i++)
    {
        int hour;
        int minute;
        scanf("%d", &hour);
        scanf("%d", &minute);
        times.push_back(My_time(hour, minute));
    }
    
    int timeToMove;
    scanf("%d", &timeToMove);
    
    //处理最晚起床时间
    int hourOfclass, minuteOfclass;
    scanf("%d", &hourOfclass);
    scanf("%d", &minuteOfclass);
    if (minuteOfclass >= timeToMove)
        minuteOfclass -= timeToMove;
    else
    {
        int haixuyaojigexiaoshi = (timeToMove - minuteOfclass) / 60 + 1;
        hourOfclass -= haixuyaojigexiaoshi;
        minuteOfclass = haixuyaojigexiaoshi * 60 + minuteOfclass - timeToMove;
    }
    My_time timeoToGetUp(hourOfclass, minuteOfclass);
    
    sort(times.begin(), times.end(), cmp);
    
    auto it = upper_bound(times.begin(), times.end(), timeoToGetUp, cmp);
    it--;
    cout<<it->hour<<" "<<it->minute<<endl;
    return 0;
}

[编程题] 牛牛的背包问题

时间限制：1秒

空间限制：32768K

牛牛准备参加学校组织的春游, 出发前牛牛准备往背包里装入一些零食, 牛牛的背包容量为w。

牛牛家里一共有n袋零食, 第i袋零食体积为v[i]。

牛牛想知道在总体积不超过背包容量的情况下,他一共有多少种零食放法(总体积为0也算一种放法)。

输入描述:

输入包括两行
第一行为两个正整数n和w(1 <= n <= 30, 1 <= w <= 2 * 10^9),表示零食的数量和背包的容量。
第二行n个正整数v[i](0 <= v[i] <= 10^9),表示每袋零食的体积。

输出描述:

输出一个正整数, 表示牛牛一共有多少种零食放法。

输入例子1:

3 10
1 2 4

输出例子1:

例子说明1:

三种零食总体积小于10,于是每种零食有放入和不放入两种情况，一共有2*2*2 = 8种情况。

思路：DFS + 记忆化搜索。

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>

using namespace std;

int n;
long long w;

int helper(vector< unordered_map<long long, int> > &hhash, vector<long long>& v, int now_pos, long long had_fill)
{
    if (hhash[now_pos + 1].find(had_fill) != hhash[now_pos + 1].end())
    {
        return hhash[now_pos + 1][had_fill];
    }
    
    int sum = 0;
    for (int i = now_pos + 1; i < v.size(); i++)
    {
        if (had_fill + v[i] <= w)
        {
            sum += helper(hhash, v, i, had_fill + v[i]);
        }
    }
    sum += 1; //不往后装了
    hhash[now_pos + 1].insert(make_pair(had_fill, sum));
    return sum;
}

int main()
{
    scanf("%d", &n);
    scanf("%d", &w);
    
    vector< unordered_map<long long, int> > hhash(n + 1);
    
    vector<long long> v(n);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    
    int ret = helper(hhash, v, -1, 0);
    printf("%d", ret);
    return 0;
}

[编程题] 数对

时间限制：1秒

空间限制：32768K

牛牛以前在老师那里得到了一个正整数数对(x, y), 牛牛忘记他们具体是多少了。

但是牛牛记得老师告诉过他x和y均不大于n, 并且x除以y的余数大于等于k。

牛牛希望你能帮他计算一共有多少个可能的数对。

输入描述:

输入包括两个正整数n,k(1 <= n <= 10^5, 0 <= k <= n - 1)。

输出描述:

对于每个测试用例, 输出一个正整数表示可能的数对数量。

输入例子1:

5 2

输出例子1:

例子说明1:

满足条件的数对有(2,3),(2,4),(2,5),(3,4),(3,5),(4,5),(5,3)

思路：必须要用long long。 x / y 枚举y。

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>

using namespace std;

int main(void)
{
    int n, k;
    unsigned long long count = 0;
    scanf("%d", &n);
    scanf("%d", &k);
    
    if (k == 0)
    {
        long long ret = n;
        ret *= ret;
        cout<<ret;
        return 0;
    }
    
    for (int y = 1; y <= n; y++)
    {
        if (y > k)
            count += y - k;
        
        if (y > k)
        {
            int cheng = 1;
            while (y * cheng + k <= n)
            {
                if (y * (cheng + 1) <= n)
                {
                    count += y * (cheng + 1) - (y * cheng + k);
                    cheng ++;
                }
                else
                {
                    count += n - (y * cheng + k) + 1;
                    break;
                }
            }
        }
    }
    cout<<count;
    return 0;
}

[编程题] 迷路的牛牛

时间限制：1秒

空间限制：32768K

牛牛去犇犇老师家补课，出门的时候面向北方，但是现在他迷路了。虽然他手里有一张地图，但是他需要知道自己面向哪个方向，请你帮帮他。

输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含一个正整数，表示转方向的次数N(N<=1000)。
接下来的一行包含一个长度为N的字符串，由L和R组成，L表示向左转，R表示向右转。

输出描述:

输出牛牛最后面向的方向，N表示北，S表示南，E表示东，W表示西。

输入例子1:

3
LRR

输出例子1:

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>

using namespace std;

int main()
{
    int n;
    string w;
    
    scanf("%d", &n);
    cin>>w;
    
    int k = 0;
    for (int i = 0; i < w.size(); i++)
    {
        if (w[i] == 'L')
        {
            k --;
        }
        else
        {
            k ++;
        }
        k = k % 4;
    }
    if (k < 0)
        k += 4;
    
    if (k == 0)
        cout<<"N";
    if (k == 1)
        cout<<"E";
    if (k == 2)
        cout<<"S";
    if (k == 3)
        cout<<"W";
    
    return 0;
}

安置路灯

时间限制：1秒

空间限制：32768K

小Q正在给一条长度为n的道路设计路灯安置方案。

为了让问题更简单,小Q把道路视为n个方格,需要照亮的地方用'.'表示, 不需要照亮的障碍物格子用'X'表示。

小Q现在要在道路上设置一些路灯, 对于安置在pos位置的路灯, 这盏路灯可以照亮pos - 1, pos, pos + 1这三个位置。

小Q希望能安置尽量少的路灯照亮所有'.'区域, 希望你能帮他计算一下最少需要多少盏路灯。

输入描述:

输入的第一行包含一个正整数t(1 <= t <= 1000), 表示测试用例数
接下来每两行一个测试数据, 第一行一个正整数n(1 <= n <= 1000),表示道路的长度。
第二行一个字符串s表示道路的构造,只包含'.'和'X'。

输出描述:

对于每个测试用例, 输出一个正整数表示最少需要多少盏路灯。

输入例子1:

2
3
.X.
11
...XX....XX

输出例子1:

1
3

思路：贪心

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>

using namespace std;

int helper(string& str)
{
    int ret = 0;
    for (int i = 0; i < str.size(); i++)
    {
        if (str[i] == '.')
        {
            ret ++;
            i += 2;
        }
    }
    return ret;
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        int len;
        scanf("%d", &len);
        string str;
        cin>>str;
        cout<<helper(str)<<endl;
    }
    return 0;
}

被3整除

时间限制：1秒

空间限制：32768K

小Q得到一个神奇的数列: 1, 12, 123,...12345678910,1234567891011...。

并且小Q对于能否被3整除这个性质很感兴趣。

小Q现在希望你能帮他计算一下从数列的第l个到第r个(包含端点)有多少个数可以被3整除。

输入描述:

输入包括两个整数l和r(1 <= l <= r <= 1e9), 表示要求解的区间两端。

输出描述:

输出一个整数, 表示区间内能被3整除的数字个数。

输入例子1:

2 5

输出例子1:

例子说明1:

12, 123, 1234, 12345...
其中12, 123, 12345能被3整除。

思路：数列的规律是每隔两个数就有一个不满足

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>

using namespace std;

int vaildnum(int k)
{
    int dengyu = k / 3;
    int yu = k % 3;
    int ret = (yu == 0) ? 0 : yu - 1;
    return dengyu * 2 + ret;
}

int main()
{
    int l, r;
    scanf("%d", &l);
    scanf("%d", &r);
    printf("%d", vaildnum(r) - vaildnum(l - 1));
    return 0;
}

牛牛找工作

时间限制：2秒

空间限制：65536K

为了找到自己满意的工作，牛牛收集了每种工作的难度和报酬。牛牛选工作的标准是在难度不超过自身能力值的情况下，牛牛选择报酬最高的工作。在牛牛选定了自己的工作后，牛牛的小伙伴们来找牛牛帮忙选工作，牛牛依然使用自己的标准来帮助小伙伴们。牛牛的小伙伴太多了，于是他只好把这个任务交给了你。

输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含两个正整数，分别表示工作的数量N(N<=100000)和小伙伴的数量M(M<=100000)。
接下来的N行每行包含两个正整数，分别表示该项工作的难度Di(Di<=1000000000)和报酬Pi(Pi<=1000000000)。
接下来的一行包含M个正整数，分别表示M个小伙伴的能力值Ai(Ai<=1000000000)。
保证不存在两项工作的报酬相同。

输出描述:

对于每个小伙伴，在单独的一行输出一个正整数表示他能得到的最高报酬。一个工作可以被多个人选择。

输入例子1:

3 3 
1 100 
10 1000 
1000000000 1001 
9 10 1000000000

输出例子1:

100 
1000 
1001

#include <iostream>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include<vector>
#include<map>
#include <set>
#include <queue>
#include <string>
#include <limits.h>
using namespace std;

struct job
{
 int cost;
 int profit;
 job(int c, int p) :cost(c), profit(p){}
};
bool cmp(const job& lhs, const job& rhs)
{
 if (lhs.cost != rhs.cost)
  return lhs.cost < rhs.cost;
 return lhs.profit > rhs.profit;
}

int main()
{
 int numOfJobs;
 int numOfPers;

 scanf("%d", &numOfJobs);
 scanf("%d", &numOfPers);

 vector<job> jobs;
 for (int i = 0; i < numOfJobs; i++)
 {
  int cost;
  int profit;
  scanf("%d", &cost);
  scanf("%d", &profit);
  jobs.push_back(job(cost,profit));
 }
 vector<int> nums(numOfPers);
 for (int i = 0; i < numOfPers; i++)
  scanf("%d", &nums[i]);
 sort(jobs.begin(), jobs.end(), cmp);
 map<int, int> njobs;
 njobs.insert(make_pair(0, 0));
 for (int i = 0; i < numOfJobs; i++)
 {
  int last = njobs.rbegin()->second;
  if (jobs[i].profit<=last)
   continue;
  njobs.insert(make_pair(jobs[i].cost, jobs[i].profit));
 }

 for (int i = 0; i < numOfPers; i++)
 {
  auto it = njobs.upper_bound(nums[i]);
  if (it == njobs.end())
   cout << njobs.rbegin()->second << endl;
  else
   cout << (--it)->second << endl;
 }
 return 0;
}

矩形重叠

时间限制：1秒

空间限制：32768K

平面内有n个矩形, 第i个矩形的左下角坐标为(x1[i], y1[i]), 右上角坐标为(x2[i], y2[i])。

如果两个或者多个矩形有公共区域则认为它们是相互重叠的(不考虑边界和角落)。

请你计算出平面内重叠矩形数量最多的地方,有多少个矩形相互重叠。

输入描述:

输入包括五行。
第一行包括一个整数n(2 <= n <= 50), 表示矩形的个数。
第二行包括n个整数x1[i](-10^9 <= x1[i] <= 10^9),表示左下角的横坐标。
第三行包括n个整数y1[i](-10^9 <= y1[i] <= 10^9),表示左下角的纵坐标。
第四行包括n个整数x2[i](-10^9 <= x2[i] <= 10^9),表示右上角的横坐标。
第五行包括n个整数y2[i](-10^9 <= y2[i] <= 10^9),表示右上角的纵坐标。

输出描述:

输出一个正整数, 表示最多的地方有多少个矩形相互重叠,如果矩形都不互相重叠,输出1。

输入例子1:

输出例子1:

思路：

存下所有的x坐标和y坐标，然后分别进行排序。然后我们得到了两个数组，一个是x坐标的数组，一个是y坐标的数组，分别都有2n个整数，就有2n*2n个点，我们算这每个点被多少个矩形包含就行。

#include <iostream>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string>

using namespace std;

class juxing
{
public:
    int lb_x;
    int lb_y;
    int rt_x;
    int rt_y;
    juxing(int a, int b, int c, int d): lb_x(a), lb_y(b), rt_x(c), rt_y(d){}
};

int main()
{
    int n;
    scanf("%d", &n);
    
    vector<int> lbX(n);
    for (int i = 0; i < n; i++)
        scanf("%d", &lbX[i]);
    vector<int> lbY(n);
    for (int i = 0; i < n; i++)
        scanf("%d", &lbY[i]);
    vector<int> rtX(n);
    for (int i = 0; i < n; i++)
        scanf("%d", &rtX[i]);
    vector<int> rtY(n);
    for (int i = 0; i < n; i++)
        scanf("%d", &rtY[i]);
    
    vector<juxing> AllJuXing;
    for (int i = 0; i < n; i++)
        AllJuXing.push_back(juxing(lbX[i], lbY[i], rtX[i], rtY[i]));

    vector<int> XX;
    for (int i = 0; i < n; i++)
    {
        XX.push_back(lbX[i]);
        XX.push_back(rtX[i]);
    }
    vector<int> YY;
    for (int i = 0; i < n; i++)
    {
        YY.push_back(lbY[i]);
        YY.push_back(rtY[i]);
    }
    
    int count = 0, ret = 0;
    for (int i = 0; i < XX.size(); i++)
    {
        for (int j = 0; j < YY.size(); j++)
        {
            for (int k = 0; k < AllJuXing.size(); k++)
            {
                if (XX[i] >= AllJuXing[k].lb_x && XX[i] < AllJuXing[k].rt_x && YY[j] >= AllJuXing[k].lb_y && YY[j] < AllJuXing[k].rt_y)
                    count ++;
            }
            ret = max(ret, count);
            count = 0;
        }
    }
    cout<<ret;
    return 0;
}