3.3: Tìm phần tử trùng lặp

 

- Tìm phần tử trùng lặp trong chuỗi (Có/Không phân biệt chữ hoa và chữ thường)

- Đếm số lần

- Phần tử lặp nhiều nhất và nhiều thứ 2 

- Xóa bỏ các phần tử lặp ( xóa hết)

- Xóa bỏ các phần tử lặp (giữ lại mỗi phần tử một lần)

Dưới đây là một cách để thực hiện các thao tác trên chuỗi trong Java, bao gồm cả việc phân biệt chữ hoa và chữ thường:

import java.util.HashMap;
import java.util.Map;

public class StringOperationsExample {
    public static void main(String[] args) {
        String str = "Hello World! Hello world!";

        // Tìm phần tử trùng lặp trong chuỗi (Có phân biệt chữ hoa và chữ thường)
        System.out.println("Phần tử trùng lặp trong chuỗi:");
        findDuplicates(str);

        // Đếm số lần xuất hiện của từng phần tử
        System.out.println("\nSố lần xuất hiện của từng phần tử:");
        countOccurrences(str);

        // Phần tử lặp nhiều nhất và nhiều thứ 2
        System.out.println("\nPhần tử lặp nhiều nhất và nhiều thứ 2:");
        findMostFrequentElements(str);

        // Xóa bỏ các phần tử lặp (xóa hết)
        System.out.println("\nChuỗi sau khi xóa bỏ các phần tử lặp (xóa hết):");
        String removedDuplicates = removeDuplicates(str);
        System.out.println(removedDuplicates);

        // Xóa bỏ các phần tử lặp (giữ lại mỗi phần tử một lần)
        System.out.println("\nChuỗi sau khi xóa bỏ các phần tử lặp (giữ lại mỗi phần tử một lần):");
        String removedDuplicatesOnce = removeDuplicatesKeepOne(str);
        System.out.println(removedDuplicatesOnce);
    }

    // Tìm phần tử trùng lặp trong chuỗi (Có phân biệt chữ hoa và chữ thường)
    public static void findDuplicates(String str) {
        Map<Character, Integer> charCount = new HashMap<>();
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        charCount.forEach((key, value) -> {
            if (value > 1) {
                System.out.println(key);
            }
        });
    }

    // Đếm số lần xuất hiện của từng phần tử
    public static void countOccurrences(String str) {
        Map<Character, Integer> charCount = new HashMap<>();
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        charCount.forEach((key, value) -> System.out.println(key + ": " + value));
    }

    // Phần tử lặp nhiều nhất và nhiều thứ 2
    public static void findMostFrequentElements(String str) {
        Map<Character, Integer> charCount = new HashMap<>();
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        int max1 = 0, max2 = 0;
        char mostFrequent = '\0', secondMostFrequent = '\0';
        for (Map.Entry<Character, Integer> entry : charCount.entrySet()) {
            if (entry.getValue() > max1) {
                max2 = max1;
                secondMostFrequent = mostFrequent;
                max1 = entry.getValue();
                mostFrequent = entry.getKey();
            } else if (entry.getValue() > max2) {
                max2 = entry.getValue();
                secondMostFrequent = entry.getKey();
            }
        }
        System.out.println("Phần tử lặp nhiều nhất: " + mostFrequent);
        System.out.println("Phần tử lặp nhiều thứ 2: " + secondMostFrequent);
    }

    // Xóa bỏ các phần tử lặp (xóa hết)
    public static String removeDuplicates(String str) {
        StringBuilder result = new StringBuilder();
        Map<Character, Integer> charCount = new HashMap<>();
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        for (char ch : str.toCharArray()) {
            if (charCount.get(ch) == 1) {
                result.append(ch);
            }
        }
        return result.toString();
    }

    // Xóa bỏ các phần tử lặp (giữ lại mỗi phần tử một lần)
    public static String removeDuplicatesKeepOne(String str) {
        StringBuilder result = new StringBuilder();
        Map<Character, Integer> charCount = new HashMap<>();
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        for (char ch : str.toCharArray()) {
            if (charCount.get(ch) == 1 || !result.toString().contains(String.valueOf(ch))) {
                result.append(ch);
            }
        }
        return result.toString();
    }
}

Dưới đây là mã Java chỉnh sửa để không phân biệt chữ hoa và chữ thường:

import java.util.HashMap;
import java.util.Map;

public class StringOperationsExample {
    public static void main(String[] args) {
        String str = "Hello World! Hello world!";

        // Tìm phần tử trùng lặp trong chuỗi (Không phân biệt chữ hoa và chữ thường)
        System.out.println("Phần tử trùng lặp trong chuỗi:");
        findDuplicatesIgnoreCase(str);

        // Đếm số lần xuất hiện của từng phần tử
        System.out.println("\nSố lần xuất hiện của từng phần tử:");
        countOccurrencesIgnoreCase(str);

        // Phần tử lặp nhiều nhất và nhiều thứ 2
        System.out.println("\nPhần tử lặp nhiều nhất và nhiều thứ 2:");
        findMostFrequentElementsIgnoreCase(str);

        // Xóa bỏ các phần tử lặp (xóa hết)
        System.out.println("\nChuỗi sau khi xóa bỏ các phần tử lặp (xóa hết):");
        String removedDuplicates = removeDuplicatesIgnoreCase(str);
        System.out.println(removedDuplicates);

        // Xóa bỏ các phần tử lặp (giữ lại mỗi phần tử một lần)
        System.out.println("\nChuỗi sau khi xóa bỏ các phần tử lặp (giữ lại mỗi phần tử một lần):");
        String removedDuplicatesOnce = removeDuplicatesKeepOneIgnoreCase(str);
        System.out.println(removedDuplicatesOnce);
    }

    // Tìm phần tử trùng lặp trong chuỗi (Không phân biệt chữ hoa và chữ thường)
    public static void findDuplicatesIgnoreCase(String str) {
        Map<Character, Integer> charCount = new HashMap<>();
        str = str.toLowerCase(); // Chuyển đổi chuỗi về chữ thường
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        charCount.forEach((key, value) -> {
            if (value > 1) {
                System.out.println(key);
            }
        });
    }

    // Đếm số lần xuất hiện của từng phần tử (Không phân biệt chữ hoa và chữ thường)
    public static void countOccurrencesIgnoreCase(String str) {
        Map<Character, Integer> charCount = new HashMap<>();
        str = str.toLowerCase(); // Chuyển đổi chuỗi về chữ thường
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        charCount.forEach((key, value) -> System.out.println(key + ": " + value));
    }

    // Phần tử lặp nhiều nhất và nhiều thứ 2 (Không phân biệt chữ hoa và chữ thường)
    public static void findMostFrequentElementsIgnoreCase(String str) {
        Map<Character, Integer> charCount = new HashMap<>();
        str = str.toLowerCase(); // Chuyển đổi chuỗi về chữ thường
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        int max1 = 0, max2 = 0;
        char mostFrequent = '\0', secondMostFrequent = '\0';
        for (Map.Entry<Character, Integer> entry : charCount.entrySet()) {
            if (entry.getValue() > max1) {
                max2 = max1;
                secondMostFrequent = mostFrequent;
                max1 = entry.getValue();
                mostFrequent = entry.getKey();
            } else if (entry.getValue() > max2) {
                max2 = entry.getValue();
                secondMostFrequent = entry.getKey();
            }
        }
        System.out.println("Phần tử lặp nhiều nhất: " + mostFrequent);
        System.out.println("Phần tử lặp nhiều thứ 2: " + secondMostFrequent);
    }

    // Xóa bỏ các phần tử lặp (xóa hết) (Không phân biệt chữ hoa và chữ thường)
    public static String removeDuplicatesIgnoreCase(String str) {
        StringBuilder result = new StringBuilder();
        Map<Character, Integer> charCount = new HashMap<>();
        str = str.toLowerCase(); // Chuyển đổi chuỗi về chữ thường
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        for (char ch : str.toCharArray()) {
            if (charCount.get(ch) == 1) {
                result.append(ch);
            }
        }
        return result.toString();
    }

    // Xóa bỏ các phần tử lặp (giữ lại mỗi phần tử một lần) (Không phân biệt chữ hoa và chữ thường)
    public static String removeDuplicatesKeepOneIgnoreCase(String str) {
        StringBuilder result = new StringBuilder();
        Map<Character, Integer> charCount = new HashMap<>();
        str = str.toLowerCase(); // Chuyển đổi chuỗi về chữ thường
        for (char ch : str.toCharArray()) {
            charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
        }
        for (char ch : str.toCharArray()) {
            if (charCount.get(ch) == 1 || !result.toString().contains(String.valueOf(ch))) {
                result.append(ch);
            }
        }
        return result.toString();
    }
}

Trong mã này, tất cả các chuỗi được chuyển đổi thành chữ thường trước khi thực hiện các thao tác, do đó chúng ta không phân biệt chữ hoa và chữ thường trong quá trình xử lý chuỗi.