1 小 y 删数字

所有数字位数总和减去所有0位的数量

const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
})

let input = []

readline.on('line', (line) => {
    input.push(line)
})

readline.on('close', () => {
    let n = Number(input[0])
    
    let arr = input[1].split(' ').map(Number)
    
    let zeroCount = 0
    let numsSum = 0
    
    for (let i = 0; i < n; i ++) {
        let tempStr = arr[i].toString()
        numsSum += tempStr.length
        for (let j = 0; j < tempStr.length; j ++) {
            if (tempStr[j] === '0') {
                zeroCount ++
            }
        }
    }

    console.log(numsSum - zeroCount)
})

2 小红的字符串切割

单纯的字符串切割问题，想好怎么处理很重要

只顾A出来，感觉写的冗余了qwq

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        String str = scanner.nextLine();
        int start = 0;
        String res = "";
        int flag = 0;
        
        for (int i = 0; i < str.length(); i ++) {
            char tempChar = str.charAt(i);
            if (i > 0) {
                char prevChar = str.charAt(i - 1);
                if (prevChar == tempChar) {
                    continue;
                } else {
                    int len = i - start;
                    
                    // 肯定 -1
                    if (len < 3 || len == 4) {
                        flag = 1;
                        System.out.println(-1);
                        break;
                    } else if (len == 7) {
                        // 长度为7别分了，直接输出
                        res += (" " + str.substring(start, i));
                        start = i;
                        continue;
                    }
                    
                    while (len % 2 == 0) {
                        // 若长度是偶数
                        res += (" " + str.substring(start, start + 3));
                        start += 3;
                        len = i - start;
                    } 
                    res += (" " + str.substring(start, i));
                    start = i;
                }
            }
        }
        
        //处理最后一段
        if (flag == 0) {
            int len = str.length() - start;
            if (len < 3 || len == 4 || len ==7) {
                System.out.println(-1);
            } else {
                while (len % 2 == 0) {
                    // 若长度是偶数
                    res += (" " + str.substring(start, start + 3));
                    start += 3;
                    len = str.length() - start;
                } 
                res += (" " + str.substring(start, str.length()));
                
                System.out.println(res.trim());            
            }            
        }
    }
}

3 小红的数字匹配

思路大于动笔折返，但是有的情况真的难以考虑全 思路：

1 首先看template首位是否为0,为0直接返回-1

2 若template首位为？，则先让首位变1

3 统计？数量，计算仅由？能组成的最大数，判断和num（第几最小）孰大孰小在这里要注意两点：

3.1 如果template首位之前为？，计算最大数时别忘了首位也能用到

3.2 "仅由？能组成的最大数"会超过long型，所以用BigInteger

4 倒序遍历template,找到其中的？，替换为当前num对应位，别忘了如果template首位的情况

大致流程是这些，细节需要自己思考 这题综合了很多java内置方法，需要仔细复盘

import java.util.*;
import java.math.BigInteger;

public class Main {
    public static void process(String template, long num) {
        char[] chars = template.toCharArray();
        int firstIsQues = 0;
        int quesNums = 0;
        
        // 若首位为？，则先让首位变为1
        if (chars[0] == '?') {
            chars[0] = '1';
            firstIsQues = 1;
        }
        
        // 统计问号个数
        for (int i = 0; i < chars.length; i ++) {
            if (chars[i] == '?') {
                quesNums ++;
            }
        }

        // 求当前template能组成的最大数
        BigInteger maxNum = new BigInteger("0");
        BigInteger nine = new BigInteger("9"); // 常量 9
        BigInteger ten = new BigInteger("10"); // 常量 10
        
        for (int i = 0; i < quesNums; i ++) {

            maxNum = maxNum.multiply(ten).add(nine); 
        }
        
        if (firstIsQues == 1) {
            // 第一位也能用
            maxNum = maxNum.multiply(ten).add(nine); 
        }

        BigInteger targetNum = new BigInteger(String.valueOf(num));
        if (maxNum.compareTo(targetNum) >= 0) {
            // 能把问好占满
            char[] numChars = Long.toString(num - 1).toCharArray();
            
            int index = numChars.length - 1;
            for (int i = chars.length - 1; i >= 0; i --) {
                if (index >= 0) {
                    if (chars[i] == '?') {
                        chars[i] = numChars[index --];
                    } else if (i == 0 && firstIsQues == 1) {
                        chars[i] = (char) (numChars[index --] + 1);
                    
                        // 第一位这里还会加超
                        if (chars[i] > '9') {
                            System.out.println(-1);
                            return;
                        }
                    }
                } else {
                    if (chars[i] == '?') {
                        chars[i] = '0';
                    }
                }
            }
            
            System.out.println(new String(chars));
        } else {
            System.out.println(-1);
        }
        
        return;
    }
    
    public static void main (String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = Integer.parseInt(scanner.nextLine());

        for (int i = 0; i < t; i ++) {
            String template = scanner.nextLine();
            long num = Integer.parseInt(scanner.nextLine());
            
            if (template.charAt(0) == '0') {
                System.out.println(-1);
                continue;
            }
            
            process(template, num);
        }
    }
}