我好像是卷 1

第一題： 完善字符串

輸入字符串（子串?dāng)?shù)、子串，形如 2 abc 123456789），子串未滿8個則填充0使其總長度達到8個字符，超過8個則分割

核心部分：

for (String part : parts) {
  // 處理每8個字符
  for (int i = 0; i < part.length(); i += 8) {
    String chunk = part.substring(i, Math.min(i + 8, part.length()));
    // 如果長度不足8，在末尾補0
    if (chunk.length() < 8) {
      // 當(dāng)chunk的長度小于8時，%-8s會在chunk的末尾添加空格，使其總長度達到8個字符
      // 然后將空格替換為0
      chunk = String.format("%-8s", chunk).replace(' ', '0');
      result.add(chunk);
    }
  }
}

第二題：十進制轉(zhuǎn)16位二進制補碼

有點奇淫巧技了，因為計算機用二進制存的直接提出來就行

public static String convertToBinary16(int num) {
    if (num < - Math.pow(2, 15) || num > Math.pow(2, 15) - 1) {
        return  num > 0 ? "0111111111111111" : "1000000000000000";
    }

    StringBuilder binary = new StringBuilder();

    // 從最高位開始，逐位檢查并添加到結(jié)果中
    for (int i = 15; i >= 0; i--) {
        // 使用位運算檢查每一位
        if ((num & (1 << i)) != 0) {
            binary.append('1');
        } else {
            binary.append('0');
        }
    }

    return binary.toString();
}

第三題：蛇形字符串

想了很久沒想明白，以為是DP啥的試了半天，最后發(fā)現(xiàn)其實什么都不用能分解問題就能寫出來，主要是題目描述太復(fù)雜了，吃一塹長一智了唉。。。太難過了

題目描述

輸入一個字符串（不含空格）， 請尋找輸入中包含所有蛇形字符串。 蛇形字符串定義：

1.蛇形字符串由連續(xù)字符對組成，其特點如下： 1.1 字符對定義：字符對由同一字母的大寫和小寫組成（前大后?。Ｈ纾篈a，Dd； 1.2 蛇形字符串中包含的字符對，必須是連續(xù)字母，并按照字母順序排序。如：AaBbCc或OoPpQqRrSs；

2.從輸入中尋找字符組成蛇形字符串（字符順序不限），符合規(guī)則： 2.1 每次尋找必須是最長的蛇形字符串； 2.2 使用過的字符不能重復(fù)使用；

詳細題目請看

解法

• 我認為最重要的一點是字符串順序不重要，這是后面一切思路的基礎(chǔ)
• 大寫字母必須緊跟小寫字母，所以確保一一對應(yīng)——如果3個A 2個a，那么最多組成兩個Aa

所以思路大致如下：

1. 統(tǒng)計輸入字符串中大寫和小寫字母的出現(xiàn)次數(shù)
2. 在大寫字母映射中尋找同時存在于小寫字母映射中的字母
3. 對這些字母進行排序，并找出最長的連續(xù)字母子串。
4. 構(gòu)建一個新字符串，將最長連續(xù)字母子串中的每個大寫字母與其對應(yīng)的小寫字母配對
5. 將構(gòu)建的字符串添加到結(jié)果列表中，并減少相應(yīng)字母的計數(shù)，如果個數(shù)為0，移除該字母
6. 重復(fù)

import java.util.*;

class SnackStr {
    // 主方法，處理輸入字符串并返回結(jié)果列表
    public List<String> snack(String s) {
        // 用于存儲大寫字母及其出現(xiàn)次數(shù)的映射
        Map<Character, Integer> up = new HashMap<>();
        // 用于存儲小寫字母及其出現(xiàn)次數(shù)的映射
        Map<Character, Integer> low = new HashMap<>();

        // 遍歷字符串中的每個字符
        for (char chr : s.toCharArray()) {
            // 如果是小寫字母，更新low映射
            if ('a' <= chr && chr <= 'z') {
                low.put(chr, low.getOrDefault(chr, 0) + 1);
            }
            // 如果是大寫字母，更新up映射
            if ('A' <= chr && chr <= 'Z') {
                up.put(chr, up.getOrDefault(chr, 0) + 1);
            }
        }

        // 用于存儲結(jié)果的列表
        List<String> res = new ArrayList<>();
        // 當(dāng)up映射不為空時，繼續(xù)處理
        while (!up.isEmpty()) {
            // 獲取同時存在于up和low映射中的字符
            // 僅處理這些字符（且只用保存大寫形式）
            List<Character> chars = getUpLowChar(up, low);
            // 如果沒有這樣的字符，跳出循環(huán)
            if (chars.isEmpty()) {
                break;
            }
            // 對字符列表進行排序
            Collections.sort(chars);
            // 獲取最長的連續(xù)字符子串
            String out = maxLen(chars);
            // 構(gòu)建結(jié)果字符串
            StringBuilder sb = new StringBuilder();
            for (char x : out.toCharArray()) {
                sb.append(x).append(Character.toLowerCase(x));
            }
            // 將結(jié)果字符串添加到結(jié)果列表中
            res.add(sb.toString());
            // 減少up和low映射中對應(yīng)字符的計數(shù)
            decrease(out, up, low);
        }
        return res;
    }

    // 獲取同時存在于up和low映射中的字符
    private List<Character> getUpLowChar(Map<Character, Integer> up, Map<Character, Integer> low) {
        List<Character> res = new ArrayList<>();
        for (char key : up.keySet()) {
            if (low.containsKey(Character.toLowerCase(key))) {
                res.add(key);
            }
        }
        return res;
    }

    // 獲取字符列表中最長的連續(xù)字符子串
    private String maxLen(List<Character> s) {
        // s 是排序后的字符列表
        if (s.isEmpty()) return "";
        StringBuilder maxEnd = new StringBuilder().append(s.getFirst());
        StringBuilder res = new StringBuilder().append(s.getFirst());
        for (int i = 1; i < s.size(); i++) {
            // s.get(i) - s.get(i - 1) == 1 檢查當(dāng)前字符是否是前一個字符的下一個字母。
            // 例如，'B' - 'A' == 1，表示它們是連續(xù)的
            if (s.get(i) - s.get(i - 1) == 1) {
                maxEnd.append(s.get(i));
            } else {
                // 不連續(xù)，從當(dāng)前開始繼續(xù)找
                maxEnd = new StringBuilder().append(s.get(i));
            }
            // 更新結(jié)果
            if (maxEnd.length() > res.length()) {
                res = new StringBuilder(maxEnd);
            }
        }
        return res.toString();
    }

    // 減少up和low映射中對應(yīng)字符的計數(shù)
    private void decrease(String s, Map<Character, Integer> up, Map<Character, Integer> low) {
        for (char chr : s.toCharArray()) {
            up.put(chr, up.get(chr) - 1);
            if (up.get(chr) == 0) {
                up.remove(chr);
            }
            char lowerChr = Character.toLowerCase(chr);
            low.put(lowerChr, low.get(lowerChr) - 1);
            if (low.get(lowerChr) == 0) {
                low.remove(lowerChr);
            }
        }
    }

    // 主方法，用于測試
    public static void main(String[] args) {
        SnackStr solution = new SnackStr();
        String test = "SwSE$3454356DD$$E#eswsxxsssAAWDxxdderfvcRFER65645hbg^^%%^UnbnvccTRChnyvcxcvVCFR";
        for (String x : solution.snack(test)) {
            System.out.println(x);
        }
    }
}