美团笔试2022.8.6

/*时间限制： 3000MS
内存限制： 589824KB
题目描述：
小美开的西点屋举办一周年活动，她准备制作一批礼盒作为对消费者的回馈，每个礼盒中都有三枚西点屋的招牌点心。西点屋共有A和B两种招牌点心，为了让消费者都能品尝到两种点心，因此每个礼盒中都要包含至少一枚A点心和一枚B点心。现在小美的西点屋内共有x枚A点心和y枚B点心，请问小美最多可以制作多少个礼盒。

输入描述
输入第一行包含一个正整数T，表示数据组数。(1<=T<=10000)

然后有T行，每行包含两个整数x和y，空格隔开，表示有x枚A点心和y枚B点心。(1<=x,y<=10^9)

输出描述
输出包含T行，每行一个整数，表示最多可以制作的礼盒数量。

样例输入
2
44 85
9 49
样例输出
43
9*/

import java.util.Scanner;
public class 礼盒 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        for (int i = 0; i <n ; i++) {
            int a=sc.nextInt();
            int b=sc.nextInt();
            System.out.println(Math.min(Math.min(a,b),(a+b)/3));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/*时间限制： 3000MS
内存限制： 589824KB
题目描述：
小美在做一个实验，这个实验会在纸带上打印出若干个数字，已知该实验所呈现出的正确结果应该是存在某一个分割处k，在k之前打印出的数字都是小于0的，而在k之后的数字应该都是大于0的，那么在k之前如果某一个数据大于等于0，那么我们认为这个数据是异常的，同理，在k之后如果某一个数据小于等于0，那么我们也认为这个数据是异常的。

现在给出小美打印的纸带，且k是未知的，那么请问在最乐观的情况下至少有多少个实验数据是异常的。(显然如果出现0，无论k为哪个时刻，这个0数据都是异常的)

输入描述
输入第一行包含一个正整数n，表示小美在纸带上打印的数字数量。(1<=n<=100000)

输入第二行包含n个整数 ，即小美在纸带上打印的数字，中间用空格隔开。数字仅会为 -1，0，1中的一个。

输出描述
输出仅包含一个整数，表示至少有多少个实验数据是异常的。

样例输入
5
0 -1 1 1 -1
样例输出
2

提示
在最乐观的情况下，k应该在第二个和第三个数字之间，此时第一个和最后一个数据是异常的。*/

package 美团笔试;



import java.util.Scanner;
public class 实验 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int  num=0;
        int[] ints1=new int[n];
        for (int i = 0; i < n; i++) {
            ints1[i]=sc.nextInt();
            if (ints1[i]==0)num++;
        }
        int[] ints=new int[n-num];
        int index=0;
        int  numa=0;
        int  numB=0;
        for (int i = 0; i < n; i++) {
            if (ints1[i]!=0){
                ints[index++]=ints1[i];
                if (ints1[i]==-1){
                    numa++;
                }else {
                    numB++;
                }
            }
        }
        int min=1000000;
        int  numC=0;


        for (int i = 0; i < ints.length; i++) {
            if (ints[i]==-1){
                numC++;
            }
            min=Math.min( i-2*numC+numa +1   ,min);
        }
        System.out.println(min+num);
    }
}
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

/*小美的魔法石共鸣
时间限制： 3000MS
内存限制： 589824KB
题目描述：
小美有n块魔法石，每块魔法石都有正反两面，每一面上都刻有一个魔法阵，初始状态下，n块魔法石都是正面向上。这n块魔法石的能量刚好可以构建一个大型魔法阵，但是需要至少一半的魔法石向上的一面铭刻的阵法相同才能触发大型魔法阵的效果。

小美希望翻转最少数量的魔法石，使得这个大型魔法阵被触发，请问她最少需要翻转多少块魔法石。

输入描述
输入第一行包含一个正整数n，表示魔法石的数量。(1<=n<=100000)

输入第二行包含n个正整数，表示n块魔法石正面铭刻的魔法阵种类，由于魔法书上记载的魔法阵数量太多，所以魔法阵编号可能是从1到10^9中的任何一个正整数。

输入第三行包含n个正整数，表示n块魔法石反面铭刻的魔法阵种类，魔法阵编号同样在1到10^9之间。

数字间两两有空格隔开

输出描述
输出仅包含一个整数，如果有解则输出最少翻转的魔法石数量，如果无解则输出-1。

样例输入
5
1 5 7 5 5
10 5 5 9 10
样例输出
0
*/

package 美团笔试;



import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class 魔法石 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] ints = new int[n];
        HashMap<Integer, Integer> map = new HashMap<>();
        HashMap<Integer, Integer> map2 = new HashMap<>();
        Set<Integer> set = new TreeSet();
        for (int i = 0; i < n; i++) {
            ints[i] = sc.nextInt();
            set.add(ints[i]);
            if (map.get(ints[i]) == null) {
                map.put(ints[i], 1);
            } else {
                map.put(ints[i], map.get(ints[i]) + 1);
            }
        }
        for (int i = 0; i < n; i++) {
            int l = sc.nextInt();
            if (l != ints[i]) {
                ints[i]=l;///呜呜 笔试的时候 少写了  这一行   通过 9
                set.add(ints[i]);
                if (map2.get(ints[i]) == null) {
                    map2.put(ints[i], 1);
                } else {
                    map2.put(ints[i], map2.get(ints[i]) + 1);
                }
            }
        }
        int min = 1000000;
        int G = n / 2 + n % 2;
        for (Integer integer : set) {
            int A = 0;
            if (map.get(integer) != null) {
                A = map.get(integer);
            }
            if (A > G) {
                min = 0;
                break;
            }
            if (map2.get(integer) != null) {
                if (A + map2.get(integer) > G) {
                    min = Math.min(min, G - A);
                }
            }
        }
        if (min == 1000000) {
            System.out.println(-1);
        } else {
            System.out.println(min);
        }
    }
}
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

/*小美的数据拆分
时间限制： 3000MS
内存限制： 589824KB
题目描述：
小美非常热衷于数据竞赛，数据竞赛是当下非常流行的一种比赛形式，在这种比赛中往往会给出一个训练集和一个测试集，由于测试集是没有标注的，因此大家为了线下评测模型的性能，通常会将训练集拆分成两个部分，即自建的训练集和测试集。

现在给出某比赛的一个训练集，小美需要按照如下规则将其拆分为训练集和测试集。

已知该训练集包含n个样本，每个样本有一个样本编号和一个类别编号。假设某一类别的样本共有m个，则将编号最小的m/2(向上取整)个样本作为训练集，将其他样本作为测试集。

输入描述
输入第一行包含两个正整数n和k，分别表示样本数量和类别数量。(1<=n<=10000,1<=k<=100)

输入第二行包含n个正整数，第i个正整数j表示第i个样本的类别编号是j。

输出描述
输出包含两行，第一行是训练集样本编号，编号从小到大输出，中间用空格隔开。第二行是测试集的样本编号，编号从小到大输出，中间用空格隔开。

样例输入
10 3
3 2 2 1 2 3 1 3 3 3
样例输出
1 2 3 4 6 8
5 7 9 10*/

package 美团笔试;


import java.util.Scanner;

public class 数据 {

        public static void main(String[] args) {
            Scanner sc=new Scanner(System.in);
            int n=sc.nextInt();
            int M=sc.nextInt();
            int[] ints=new int[M];
            int[] ints1=new int[n];
            for (int i = 0; i <n ; i++) {
                ints1[i]=sc.nextInt();
                ints[ ints1[i]-1]++;
            }
            int mun=0;
            for (int i = 0; i <M ; i++) {
                ints[i]= ints[i]/2+ ints[i]%2;
                mun+=ints[i];
            }
            int[] INTS1=new int[ mun];
            int[] INTS2=new int[ n-mun];
            int index1=0;
            int index2=0;
            for (int i = 0; i <n ; i++) {
               if (ints[ints1[i]-1]>0){
                   ints[ints1[i]-1]--;
                   INTS1[index1++]=i+1;
               }else {
                   INTS2[index2++]=i+1;
               }
            }
            for (int i : INTS1) {
                System.out.print(i+" ");
            }
            System.out.println();
            for (int i : INTS2) {
                System.out.print(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
44

/*字符串第k位
时间限制： 3000MS
内存限制： 589824KB
题目描述：
小美和小团拥有一个字符串生成机器，每次将字符串s丢入这个机器中，这个机器将会弹出s+r(s)+”wow”，其中，加号表示字符串的拼接，r(s)表示将字符串s逆序。

例如当s=”abc”时，得到的字符串为s+r(s)+”wow”=”abccbawow”。

当s=”MeiTuan”时，得到的字符串为”MeiTuannauTieMwow”。

小美和小团想知道，如果有一个初始字符串”MeiTuan”，然后将这个字符串丢入机器得到一个新串，然后不断地将新串再次丢入机器中，循环往复得到的无限长的字符串的第k位字符（k从1开始）是什么？（根据生成规则可知，每次丢入机器的串都会是生成的结果串的一个前缀）

输入描述
第一行是一个整数T，表示有T个询问。

接下来T行每行一个整数k，表示询问无限长字符串中第k个字符是多少。

1<=T<=10, 1<=k<=10^18

输出描述
T行，第 i 行包含一个字符，表示第i个询问的答案。

样例输入
3
31
51
67
样例输出
T
T
n

提示
第1次生成的串为”MeiTuannauTieMwow”

第2次生成的串为”MeiTuannauTieMwowwowMeiTuannauTieMwow”

第3次生成的串为

”MeiTuannauTieMwowwowMeiTuannauTieMwowwowMeiTuannauTieMwowwowMeiTuannauTieMwow”

该字符串的第31、51、67为分别为T、T、n

• */

package 美团笔试;


import java.util.Scanner;

public class 字符串k位 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        char[] chars1=new char[n];
        for (int i = 0; i <n ; i++) {
            chars1[i]=bianhau(sc.nextLong());
        }

        for (char c : chars1) {
            System.out.print(c+" ");
        }
    }

    private static char bianhau(long nextLong) {
        char[] chars={'M','e','i','T','u','a','n'};
        long[] longs={7L,17L,37L,77L,157L,317L,637L,1277L,2557L,5117L,10237L,20477L,40957L,81917L,163837L,327677L,655357L,1310717L,2621437L,5242877L,10485757L,20971517L,41943037L,83886077L,167772157L,335544317L,671088637L,1342177277L,2684354557L,5368709117L,10737418237L,21474836477L,42949672957L,85899345917L,171798691837L,343597383677L,687194767357L,1374389534717L,2748779069437L,5497558138877L,10995116277757L,21990232555517L,43980465111037L,87960930222077L,175921860444157L,351843720888317L,703687441776637L,1407374883553277L,2814749767106557L,5629499534213117L,11258999068426237L,22517998136852477L,45035996273704957L,90071992547409917L,180143985094819837L,360287970189639677L,720575940379279357L,1441151880758558717L};
        while (nextLong>longs[0]){
            int index=0;
            while (longs[index]<nextLong)index++;
            if (nextLong==longs[index]||nextLong==longs[index]-2){
                return 'w';
            }
            if (nextLong==longs[index]-1){
                return 'o';
            }
            nextLong=longs[index]-2-nextLong;
        }
        return chars[(int) (nextLong-1)];
    }
}

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