360 3.6日笔试编程题

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * @ClassName: Test_360_1
 * @Description:
 * @author: LiuGe
 * @date: 2022/3/6
 */
public class Test_360_1 {

    public static void main(String[] args) {
        /**
         * 第一题
         * 现在的调查问卷越来越多了，所以出现了很多人恶意刷问卷的情况，已知某问卷需要填写名字，，
         * 则我们认为这个名字是真实有效的，否则就判定为恶意填写问卷。
         * 请你判断出由多少有效问卷（只要名字是真实有效的，就认为问卷有效
         *
         */
        // 如果名字仅由大小写英文字母组成且长度不超过10即为有效
        /**
         * 输入第一行包含一个正整数n，表示收到的问卷数量。(1<=n<=2000)
         * 接下来有n行，每行有一个由大小写英文字母，数字，下划线组成的字符串，分别表示一份问卷的名字，字符串长度不超过100。
         * 输出只有一个整数，表示有效问卷数量。
         */
        Scanner scanner = new Scanner(System.in);
        // 获取问卷数量和问卷名称
        int testCount = scanner.nextInt();
        // 对问卷数量进行控制
        if(testCount < 1 || testCount > 2000){
            System.exit(0);
        }
        List<String> inputStrings = new ArrayList<>();
        for(int i = 0;i < testCount;i++){
            String next = scanner.next();
            inputStrings.add(next);
        }
        // 用数组来存储是否合法
        boolean[] isLegal = new boolean[inputStrings.size()];
        int[] numbers = {0,1,2,3,4,5,6,7,8,9};
        // 赋予初值
        Arrays.fill(isLegal, false);
        // 开始校验
        for(int i = 0;i < inputStrings.size();i++){
            String inputString = inputStrings.get(i);
            // 1、首先判断长度
            if(inputString.length() > 100){
                isLegal[i] = false;
            }
            if(inputString.length() > 0 && inputString.length() <= 10){
                isLegal[i] = true;
            }else{
                continue;
            }
            // 2、看看是否包括数字和下划线
            for(int j = 0;j < inputString.length();j++){
                char sName = inputString.charAt(j);
                for(int k = 0;k < 10;k++){
                    if(sName == numbers[k]){
                       isLegal[i] = false;
                       break;
                    }
                }
            }
            if(inputString.contains("_")){
                isLegal[i] = false;
                continue;
            }
            // 3、接下来判断是否包含大小写英文字母
            String s = inputString.toUpperCase();
            for(int j = 0;j < s.length();j++){
                char sName = s.charAt(j);
                isLegal[i] = sName >= 65 && sName <= 97;
            }
        }
        // 统计满足要求的个数
        int resultCount = 0;
        for (boolean b : isLegal) {
            if (b) {
                resultCount++;
            }
        }
        System.out.println(resultCount);

    }
}

import java.util.*;

/**
 * @ClassName: Test_360_2
 * @Description:
 * @author: LiuGe
 * @date: 2022/3/6
 */
public class Test_360_2 {

    public static void main(String[] args) {
        /**
         * 第二题
         * 有n个黑白棋子，它们的一面是黑色，一面是白色。它们被排成一行，位置可以用标号1~n来表示。一开始，所有的棋子都是黑色向上，
         * 有q次操作，每次操作将位置标号在区间[L, R]内的所有棋子翻转（原来黑色变白色，原来白色变黑色）。
         * 请在每次操作后，求这n个棋子中，黑色向上的棋子个数。
         */

        /**
         * 输入：第一行两个整数 n, q，1 <= n <= 1018, q <= 300;后面q行，每行两个整数 L,R，1 <= L <=R <= n。
         * 输出：q行，每行一个整数，表示每次操作后黑色向上的棋子个数。
         */
        Scanner scanner = new Scanner(System.in);
        int chessCount = scanner.nextInt();
        int reverseCount = scanner.nextInt();
        // 校验输入参数
        if (chessCount > 1018 || chessCount < 1) {
            System.exit(0);
        }
        if (reverseCount > 300 || reverseCount < 0) {
            System.exit(0);
        }
        // 用数组来表示黑白棋子，其中0为白，1为黑，默认全为黑
        int[] chess = new int[chessCount];
        Arrays.fill(chess, 1);
        // 读取后几行的操作范围，并存储起来
        Map<Integer, Integer> LRMap = new HashMap<>();
        for (int i = 0; i < reverseCount; i++) {
            int L = scanner.nextInt();
            int R = scanner.nextInt();
            if (L > R) {
                System.exit(0);
            }
            if (L < 1 || L > chessCount) {
                System.exit(0);
            }
            if (R > chessCount) {
                System.exit(0);
            }
            LRMap.put(L, R);
        }
        // 翻转棋子
        Set<Integer> LRKeys = LRMap.keySet();
        int blackCount;
        for (Integer L : LRKeys) {
            blackCount = 0;
            Integer R = LRMap.get(L);
            // 翻转[L,R]的棋子
            for (int i = L - 1; i < R; i++) {
                chess[i] = (chess[i] + 1) % 2;
            }

            // 翻转结束后输出黑色向上的个数
            for (int i = 0; i < chessCount; i++) {
                if (chess[i] == 1) {
                    blackCount++;
                }
            }
            System.out.println(blackCount);
        }
    }
}