【算法练习】小红书230326实习笔试_小红书暑假实习笔试

涂色

时间限制： 3000MS
内存限制： 589824KB

题目描述：
给出一个数组。你需要求出按顺序对其进行一系列区间操作后最终所得的数组。
操作有三种：
将下标在L到R之间的元素全部或上X。
将下标在L到R之间的元素全部与上X。
将下标在L到R之间的元素全部设为X。

输入描述
第一行有一个正整数N(1<=N<=100000)，代表数组的长度。
第二行有N个非负整数，范围在0到2^20-1之间，代表数组中的元素。
第三行有一个正整数M(1<=M<=100000)，代表操作次数。
第四行有M个正整数，代表M次操作中的区间左端点L。
第五行有M个正整数，代表M次操作中的区间右端点R。
第六行是一个长度为M的字符串，|代表操作1，&代表操作2，=代表操作3。
第七行有M个正整数，代表M次操作中的参数X。

输出描述
在一行中输出N个数，代表所有操作按顺序完成后最终所得的数组。

样例输入

4
5 4 7 4
4
1 2 3 2
4 3 4 2
=|&=
8 3 6 2
1
2
3
4
5
6
7

样例输出

8 2 2 0
1

Java实现：

public class Tuse {
    public static void operate(char f,int[] num,int left,int right,int x){
        if(f=='='){
            for(int i=left;i<=right;i++){
                num[i]=x;
            }
        }else if(f=='|'){
            for(int i=left;i<=right;i++){
                num[i]=num[i]|x;
            }
        }else{//&
            for(int i=left;i<=right;i++){
                num[i]=num[i]&x;
            }
        }
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        int[] num=new int[n];
        for(int i=0;i<n;i++){
            num[i]=in.nextInt();
        }
        int m=in.nextInt();
        int[][] range=new int[2][m];
        for(int i=0;i<2;i++){
            for(int j=0;j<m;j++){
                range[i][j]=in.nextInt();
            }
        }
        String str=in.next();
        int[] x=new int[m];
        for(int i=0;i<m;i++){
            x[i]=in.nextInt();
        }
        for(int i=0;i<str.length();i++){
            operate(str.charAt(i),num,range[0][i]-1,range[1][i]-1,x[i]);
        }
        for(int i=0;i<num.length;i++){
            System.out.print(num[i]+" ");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

K排序

时间限制： 3000MS
内存限制： 589824KB

题目描述：
​ 在算法中，有各种各样的排序算法，例如归并排序，冒泡排序，快速排序等等。本题中，我们会使用一种新的排序算法：K排序。
​ K排序算法描述如下：首先，算法需要按照某种规则选择该数列上至多K个位置，将其对应的数抽出来，其他的数都往左对齐，之后这K个数排好序之后依次放在原数列末尾。以上过程算作一次操作。
​ 例如，对于数列[1,3,5,4,2]，当K=2时可以选择数字5和4，之后数列变成[1,3,2,4,5]。
​ 你的任务是：对于给定的数列，你需要计算出最少需要多少次上述操作，使得整个数列从小到大排好序？

输入描述:
第一行一个正整数T，表示有T组数据。
对于每一组数据，第一行输入两个正整数n,k；第二行输入n个数a1,a2,…,an。该序列是一个1~n的排列。
对于所有数据：1≤k≤n≤105,1≤ai≤n, ai≠aj,1≤T≤5

输出描述:
对于每一组数据，输出一行一个整数，表示答案。

样例输入:

2
5 1
1 2 3 4 5
5 2
1 3 5 4 2
1
2
3
4
5

样例输出:

0
2
1
2

提示
样例解释第一组数据，原数列已经排好序，则无需进行任何操作；第二组数据，操作如下：[1,3,5,4,2] -> [1,5,4,2,3][1,5,4,2,3] -> [1,2,3,4,5]

思路：
注意：含有n个数的数组本来就是一个1~n的排列
因为每次取k个数都是放在末尾，所以末尾的数一定是有序的
如何保证前面的数有序呢？
我们需要首先找到一个子序列，该子序列是一个顺序排列，也就是说是1,2,3…
然后将剩余的数字进行K排序，并全部挪到子序列的后面，最少需要多少次K排序呢？
最少操作次数：将剩余n-k个数按照k个一组组合放到后面！

Java实现：

import java.util.*;

public class Ksort {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T=in.nextInt();
        for(int i=0;i<T;i++){
            int n=in.nextInt();
            int k=in.nextInt();
            int[] num=new int[n];
            int target=1;
            for(int j=0;j<n;j++){
                num[j]=in.nextInt();
                if(num[j]==target){
                    target++;
                }
            }
            int res=n-target+1;
            if(res%k==0){
                res=res/k;
            }else{
                res=res/k+1;
            }
            System.out.println(res);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

密码学

时间限制： 3000MS
内存限制： 589824KB

题目描述：
​ 小明学会了一种加密方式。他定义suc(x)为x在字母表中的后继，例如a的后继为b，b的后继为c… （即按字母表的顺序后一个）。特别的，z的后继为a。对于一个原字符串S，将其中每个字母x都替换成其三重后继，即suc(suc(suc(x)))的字母，即完成了加密。
​ 例如，abc加密后变成def （suc(suc(suc(a)))=d suc(suc(suc(b)))=e suc(suc(suc©))=f）
​ 现在小明知道一个加密后的字符串S’，想请你找出他的原串S

输入描述：
第一行一个正整数N，表示加密后的字符串长度
接下来一行是长度为N的字符串S’，含义如上。保证仅包含小写英文字母。
对于所有数据：1≤N≤50000

输出描述：
一行，一个长度为N的字符串S，表示答案。

样例输入：

3
def
1
2

样例输出:

abc
1

Java实现：

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String s = sc.next();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            // 逆向推出原字符
            char origin = (char) ((c - 'a' - 3 + 26) % 26 + 'a');
            sb.append(origin);
        }
        System.out.println(sb);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

参考：
https://leetcode.cn/circle/discuss/fDSyHY/
https://zhuanlan.zhihu.com/p/650323838