深信服-逆向笔试复盘 9月1日

1、删除重复数据并排序

方法一是自己做的，然后发现使用TreeSet更方便，方法二
法一

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class arr {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> arr = new ArrayList<>();
        while(sc.hasNext()){
            int n = sc.nextInt();
//            int[] arr = new int[n];
            for(int i = 0; i < n; i++){
                int num = sc.nextInt();
                if(num >= 1 && num <= 500 && !arr.contains(num)){
                    arr.add(num);
                }
            }
            break;
        }
        Collections.sort(arr);
        for(Integer i : arr){
            System.out.println(i);
        }
    }
}

法二

import java.util.Scanner;
import java.util.TreeSet;

public class ShenxinfuTest1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Integer len = Integer.valueOf(sc.nextLine());
        TreeSet<Integer> set = new TreeSet<>();
        for(int i = 0; i < len; i++){
            Integer n = Integer.valueOf(sc.nextLine());
            if(n >= 1 && n <= 500){
                set.add(n);
            }
        }
        for (int j : set){
            System.out.println(j);
        }
    }
}

2、

这个题，因为排好序后，重新合并的时候，i设置为0，奇偶位置判断出错，导致只过了50%
收获：Arrays.sort(arr),字符分大小从小到大进行排序

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class str11 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] s = sc.nextLine().split(" ");
        String str = s[0] + s[1];
//        System.out.println(str);
        String str1 = "";  //奇
        String str2 = "";  //偶
        for(int i = 1; i <= str.length(); i++){
            if(i % 2 != 0){
                str1 += str.charAt(i - 1);
            }else{
                str2 += str.charAt(i - 1);
            }
        }
//        System.out.println(str1);
//        System.out.println(str2);
        char[] chars1 = str1.toCharArray();
        char[] chars2 = str2.toCharArray();
        Arrays.sort(chars1);
        Arrays.sort(chars2);
        StringBuilder sb = new StringBuilder();
        int index1 = 0, index2 = 0;
        for(int i = 0; i < str.length(); i++){
            if(index1 < chars1.length && i % 2 == 0){
                char c = transfer(chars1[index1++]);
                sb.append(c);
            }else if(index2 < chars2.length && i % 2 != 0){
                char c = transfer(chars2[index2++]);
                sb.append(c);
            }
        }
        System.out.println(sb.toString());
    }

    public static char transfer(char c){
        switch (c){
            case'1': return '8';
            case'2': return '4';
            case'3': return 'C';
            case'4': return '2';
            case'5': return 'A';
            case'7': return 'E';
            case'8': return '1';
            case'a': return '5';
            case'A': return '5';
            case'b': return 'D';
            case'B': return 'D';
            case'c': return '3';
            case'C': return '3';
            case'd': return 'B';
            case'D': return 'B';
            case'e': return '7';
            case'E': return '7';
            case'f': return 'F';
            default:return c;
        }
    }
}

思考:当时改的时候错以为Arrays.sort（）是从大到小排序，浪费了很多时间，还是要多刷题，下来的时候考虑到一个问题，如果不区分大小，题目要求需要排序，但是要按照原先的大小写进行输出，之前看见一个类似的，Collection.sort和list.sort（）可以

编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y
数据范围：输入的字符串长度满足

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
 
public class Main{
    public static void main(String[] args) throws IOException{
//         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//         String s = "";
//         while((s = br.readLine()) != null){
//             String res = sort(s);
//             System.out.println(res);
//         }
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            String res = sort(str);
            System.out.println(res);
        }
    }
    public static String sort(String str){
        //1、先存储str里的字符
        List<Character> list = new ArrayList<>();
        for(char ch : str.toCharArray()){
            if(Character.isLetter(ch)){
                list.add(ch);
            }
        }
        //2、英文字母排序
        list.sort(new Comparator<Character>(){
            public int compare(Character o1, Character o2){
                return Character.toLowerCase(o1) - Character.toLowerCase(o2);
            }
        });
        //输出
        StringBuilder sb = new StringBuilder();
        for(int i = 0, j = 0; i < str.length(); i++){
            if(Character.isLetter(str.charAt(i))){
                sb.append(list.get(j++));
            }else{
                sb.append(str.charAt(i));
            }
        }
        return sb.toString();
    }
}

字符区分大小写排序，可直接用Arrays.sort()

        char[] chars = {'B', 'c', 'a', 'b', 'E', 'd'};
        Arrays.sort(chars);
        System.out.println(Arrays.sort(chars));
        //output
        [B, E, a, b, c, d]

不区分大小写排序

public class paixu {
    public static void main(String[] args) {
        char[] chars = {'B', 'c', 'a', 'b', 'E', 'd'};
//        Arrays.sort(chars);
        ArrayList<Character> list = new ArrayList<>();
        for(char ch : chars){
            if(Character.isLetter(ch)){
                list.add(ch);
            }
        }
        list.sort(new Comparator<Character>() {
            @Override
            public int compare(Character o1, Character o2) {
                return Character.toLowerCase(o1) - Character.toLowerCase(o2);
            }
        });
        System.out.println(list.toString());
    }
}
//output
[a, B, b, c, d, E]