查找兄弟单词

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        String[] ss = s.split(" ");
        int n = Integer.parseInt(ss[0]);
        int k = Integer.parseInt(ss[ss.length-1]);
        String st = ss[ss.length-2];
        char[] x = st.toCharArray();
        Arrays.sort(x);//对x进行排序
        int result = 0; //存储有多少兄弟字符
        List list = new ArrayList();//存储兄弟字符
        for (int i = 1; i < n+1; i++) {
            int count = 0;//计数，记录排序后数组中相同的字符
            //如果长度都不相同，那一定不相同
            if (ss[i].length() != st.length()) {
                continue;
            }
            //在未排序前就相同，也不是兄弟字符
            if (ss[i].equals(st)){
                continue;
            }
            //拿到ss中的数据，并转化成char数组，然后进行排序
            String compare = ss[i];
            char[] com = compare.toCharArray();
            Arrays.sort(com);//对com进行排序
            // 比较排序后的char数组，x,com
            for (int j = 0; j < st.length(); j++) {
                if (x[j] == com[j]) {
                    count++;
                }else break;
            }
            //与st比较字符串长度相同时，为兄弟字符
            if (count == st.length()) {
                result++;
                list.add(ss[i]);

            }
        }
        Collections.sort(list);
        //输出有多少兄弟单词
        System.out.println(result);
        //如果k有效，则输出第k个兄弟单词
        if(k-1<list.size()){
            System.out.println(list.get(k-1));
        }
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String input = in.nextLine();
        String[] strs = input.split(" ");
        int n = Integer.valueOf(strs[0]);
        int k = Integer.parseInt(strs[strs.length - 1]);
        String x = strs[strs.length - 2];
        char[] chx = x.toCharArray();
        Arrays.sort(chx);
        ArrayList<String> als = new ArrayList<>();

        //逐个判断每个单词是否是兄弟单词
        for (int i = 1; i <= n; i++) {
            if (x.equals(strs[i]) || strs[i].length() != x.length()) {
                continue;//长度相等或字符串相等则非兄弟字符
            } else {
                char[] chs = strs[i].toCharArray();
                Arrays.sort(chs);
                if (Arrays.equals(chx, chs)) {
                    als.add(strs[i]);//是兄弟字符久添加
                }
            }
        }

        als.sort((o1, o2)-> {return o1.compareTo(o2);}); //字符串列表按字典升序排序
        System.out.println(als.size());
        if (k <= als.size()) {
            System.out.println(als.get(k - 1));//k在兄弟单词范围内时输出
        }

    }
}

import java.util.Scanner;

import java.util.ArrayList;

import java.util.Arrays;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String []str=in.nextLine().split(" ");
        int indexLookFor=Integer.valueOf(str[str.length-1]);
        String bro=str[str.length-2];
        int len=bro.length();
        ArrayList<String> res=new ArrayList<>();
        char[]temp=bro.toCharArray();
        Arrays.sort(temp);
        getbro(new String(temp),res,new boolean[bro.length()],new StringBuilder());
        ArrayList<String>then=new ArrayList<>();
        for(int i=1;i<str.length-2;++i){
            if(str[i].length()!=bro.length())continue;
            if(res.contains(str[i])&&!str[i].equals(bro)){
                then.add(str[i]);
            }
        }
        then.sort(null);
        System.out.println(then.size());
        if(!then.isEmpty()&&indexLookFor-1<then.size()){
            System.out.println(then.get(indexLookFor-1));
        }

    }
    public static void getbro(String bro,ArrayList<String>res,boolean[]used,StringBuilder sb){
        if(sb.length()==bro.length()){
            res.add(new String (sb.toString()));
            return;
        }
        for(int i=0;i<bro.length();++i){
            if(used[i]||(i>1&&bro.charAt(i)==bro.charAt(i-1)&&!used[i-1])){
                continue;
            }
            used[i]=true;
            sb.append(bro.charAt(i));
            getbro(bro,res,used,sb);
            sb.delete(sb.length()-1,sb.length());
            used[i]=false;
        }
    }
}

TreeMap保证key的字典序比较麻烦，性能较差。可以用List来存储，再用Collections.sort()来排序性能要更高，
另外返回结果时不需要一个个去遍历TreeMap，直到遍历了k个字符串再返回。用List可以直接取k - 1索引的字符串即可(如果有)
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] str = in.nextLine().split(" ");
        int n = Integer.valueOf(str[0]);
        int k = Integer.valueOf(str[str.length - 1]);
        String target = str[str.length - 2];
        char[] sortedTarget = target.toCharArray();
        Arrays.sort(sortedTarget);
        int sum = 0;
        ArrayList<String> list = new ArrayList<>();
        for (int i = 1; i < str.length - 2; i++) {
            char[] SortedTemp = str[i].toCharArray();
            Arrays.sort(SortedTemp);
            if (str[i].length() == target.length() && !str[i].equals(target) &&
                    Arrays.equals(sortedTarget, SortedTemp)) {
                list.add(str[i]);
                sum++;
            }
        }
        Collections.sort(list);
        System.out.println(sum);
        if (list.size() >= k) {
            System.out.println(list.get(k - 1));
        }
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String str = in.nextLine();//获取输入的字符串
        String[] arr = str.split(" ");//按照" "分割，获取数组
        int n = Integer.parseInt(arr[0]);//第一个为输入的单词数量
        String[] arr2 = new String[n];//创建单词数组存储单词
        for (int i = 1; i <= n ;i++){//将单词存入单词数组中
            arr2[i-1]=arr[i];
        }
        //倒数第二个为需要对比的单词
        String x = arr[arr.length-2];
        int xLength = x.length();
        //需要对比的单词取出所有的字符，并且进行排序
        char[] xChars = x.toCharArray();
        Arrays.sort(xChars);
        String xSort = new String(xChars);
        //最后一位为要输出第几位兄弟单词
        int k = Integer.parseInt(arr[arr.length-1]);
        //存储arr2中所找到的兄弟单词
        List<String> arr2Brother = new ArrayList<>();
        //列出arr2中含有的x的兄弟单词
        for (int i = 0;i < arr2.length;i++){
            if (arr2[i].length() != xLength || arr2[i].equals(x)){
                //长度不同，必不可能为兄弟单词，相同，也不是兄弟单词
                continue;
            }
            char[] temp = arr2[i].toCharArray();
            Arrays.sort(temp);
            if (new String(xChars).equals(new String(temp))){
                arr2Brother.add(arr2[i]);
            }
        }
        //排序兄弟单词
        arr2Brother.sort(Comparator.naturalOrder());//升序  arr2Brother.sort(null);
        //arr2Brother.sort(Comparator.reverseOrder());//降序
        System.out.println(arr2Brother.size());//输出兄弟单词个数
        if (arr2Brother.size()>0 && k <= arr2Brother.size()){//如果k小于兄弟单词列表长度，则需要输出的兄弟单词存在
            System.out.println(arr2Brother.get(k-1));
        }
        //列出x所有的兄弟单词 效率低
        // List<String> brother = new ArrayList<>(); 
        // List<String> result = new ArrayList<>(); 
        // brotherFind(x.toCharArray(),0,brother);
        // int count = 0;
        // for (int i = 0; i < arr2.length;i++){
        //     if (arr2[i].equals(x) || arr2[i].length() != xLength){//如果是相同的单词或者长度不同，则跳过
        //         continue;
        //     } else if (brother.contains(arr2[i])){
        //         count++;
        //         result.add(arr2[i]);
        //     }
        // }
        // result.sort(null);
        // System.out.println(count);
        // if (k <= result.size() && k > 0) {//如果k小于兄弟单词列表长度，则需要输出的兄弟单词存在
        //     System.out.println(result.get(k-1));
        // }
        
    }

    //列出所有的兄弟单词
    public static void brotherFind(char[] chars,int start ,List<String> result){
        /** 从第start位开始固定，并与之后的字符进行替换 */
        if (start == chars.length){
            result.add(new String(chars));
        } else {
            for (int i = start; i < chars.length; i++){
                //从第start位开始固定，并与之后的字符进行替换
                swap(chars,start,i);
                brotherFind(chars,start+1,result);//递归，找到第start位所有的兄弟单词
                swap(chars,start,i);//将替换过的字符替换回来
            }
        }
        
    }
    public static void swap(char[] chars,int x,int y){
        char temp = chars[x];
        chars[x] = chars[y];
        chars[y] = temp;
    }
}

package com.hw.nk;

import java.util.*;

/*
思路：
1. 将字符型x切割成字符串，并统计每个字符串出现了几次
2. 将输入的比较字符串集合，也分别切割成字符串，并统计每个字符串出现了几次
3. 上述的都用TreeMap集合存储，所以是有序的，如果集合equals比较，相等即为兄弟串（因为每种字符只要出现次数一样，不管如何排序都一样的）
4. 当为兄弟串时，存储集合的索引，便于后续输出
*/

public class Test27 {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String s = sc.nextLine();
    String[] s1 = s.split(" ");
    String sourceStr = s1[s1.length-2];
    int k = Integer.parseInt(s1[s1.length-1]);
    List<String> list = new ArrayList();
    for (int i = 1; i < s1.length - 2; i++) {
        list.add(s1[i]);
    }
    TreeMap<Character,Integer> sourceMap = new TreeMap<>();
    for (char c : sourceStr.toCharArray()){
        sourceMap.put(c,sourceMap.getOrDefault(c,0)+1);
    }
    int num = 0;
    List<Integer> result = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
        if(!list.get(i).equals(sourceStr)){
            TreeMap<Character,Integer> targetMap = new TreeMap<>();
            for (char c : list.get(i).toCharArray()){
                targetMap.put(c,targetMap.getOrDefault(c,0)+1);
            }
            if(targetMap.equals(sourceMap)){
                result.add(i);
                num++;
            }
        }
    }
    System.out.println(num);
    if(num != 0 && num >= k){
        System.out.println(list.get(result.get(k-1)));
    }
}

}

用例通过率90%，还有10%哪位大佬能帮忙看看

import java.util.*;

import java.util.stream.Collectors;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String[] input = in.nextLine().split(" ");
            int length = Integer.parseInt(input[0]);
            String x = input[length+1];
            int index = Integer.parseInt(input[length+2]);
            List<String> list = new ArrayList<>();
            for(int i=0;i<length;i++){
                list.add(input[i+1]);
            }
            // 过滤掉完全一致，以及长度不符合的单词
            List<String> list2 = list.stream().filter(a->((a.compareTo(x)!=0)&&(a.length()==x.length()))).collect(Collectors.toList());
            List<String> list3 = new ArrayList<>();
            // 判断兄弟数
            for(String item : list2){
                String item1 = item;
                String x1 = x;
                boolean isBro = true;
                for(int i =0;i<item.length();i++){
                    String ch = item.charAt(i)+"";
                    // 两者同时去除同样的字符，若去除过程中出现两个单词长度不一致的情况，则不是兄弟数
                    item1 = item1.replace(ch,"");
                    x1 = x1.replace(ch,"");
                    if(x1.length() != item1.length()){
                        isBro = false;
                        break;
                    }
                }
                if(isBro){
                    list3.add(item);
                }
            }
            // 按照字典排序
            list3.sort((a,b)->a.compareTo(b));
            System.out.println(list3.size());
            // 兄弟数不少于1，并且给定下标小于等于兄弟数量，则打印指定下标的兄弟数
            if((index-1)<=list3.size() && (list3.size()!=0)){
                System.out.println(list3.get(index-1));
            }
        }
    }
}

import java.util.Scanner;
import java.util.Arrays;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String s = in.nextLine();
            String[] arr = s.split(" ");
            int target = Integer.parseInt(arr[arr.length-1]);
            String targetStr = arr[arr.length-2];
            String[] targetArr = targetStr.split("");
            Arrays.sort(targetArr);
            List<String> targetList = Arrays.asList(targetArr);
            Map<List<String>,String> map = new HashMap<>();
            map.put(targetList,targetStr);
            List<String> resList = new ArrayList<>();
            for (int i=1;i<arr.length-2;i++) {
                String item = arr[i];
                String[] itemArr = item.split("");
                Arrays.sort(itemArr);
                List<String> itemList = Arrays.asList(itemArr);
                if (map.get(itemList) != null && !targetStr.equals(item)) {
                    resList.add(item);
                }
            }
            System.out.println(resList.size());
            Collections.sort(resList);
            if (target - 1 < resList.size()) {
                System.out.println(resList.get(target - 1));
            }
        }
    }
} 

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String nextLine = sc.nextLine();
        String[] strings = nextLine.split(" ");
        int num = Integer.parseInt(strings[0]);
        int find = Integer.parseInt(strings[num + 2]);
        ArrayList<String> arrayList = new ArrayList<>();
        for (int i = 1; i < strings.length - 2; i++) {
            arrayList.add(strings[i]);
        }
        //Collections.sort(arrayList);
        String target = strings[num + 1];
        char[] chars = target.toCharArray();
        Arrays.sort(chars);
        int sum = 0;
        ArrayList<String> brother = new ArrayList<>();
        for (String s : arrayList) {
            char[] charArray = s.toCharArray();
            Arrays.sort(charArray);
            if (Arrays.equals(charArray, chars) && !s.equals(target)){
                sum++;
                brother.add(s);
                //System.out.println(s);
            }
        }
        System.out.println(sum);
        Collections.sort(brother);
        if (find < brother.size()){
            System.out.println(brother.get(find - 1));
        }
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        List<String> r = new ArrayList();
        while (n -- > 0) {
            r.add(in.next());
        }
        String t = in.next();
        int x = in.nextInt();
        List<String> result = new ArrayList();
        for (String st : r) {
            if (st.length() != t.length() || st.equals(t)) {
                continue;
            }
            // 这里不能用set，会去重，人傻了
            List<String> set = new ArrayList(Arrays.asList(t.split("")));
            for (int i = 0; i < st.length(); ++ i) {
                set.remove(st.charAt(i) + "");
            }
            if (set.isEmpty()){
                result.add(st);
            }
        }
        Collections.sort(result);
        System.out.println(result.size());
        if (x < result.size()) {
            System.out.println(result.get(x - 1));
        }
    }
}

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

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        List<String> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            String item = in.next();
            list.add(item);
        }
        Collections.sort(list);
        String target = in.next();
        int index = in.nextInt();
        int count = 0;
        String targetWord = "";
        char[] arr1 = target.toCharArray();
        Arrays.sort(arr1);
        for (String word : list) {

            if (word.equals(target) || word.length() != target.length()) {
                continue;
            }
            char[] arr2 = word.toCharArray();
            Arrays.sort(arr2);
            if (!Arrays.equals(arr1, arr2)) {
                continue;
            }
            count ++;
            if (count == index) {
                targetWord = word;
            }

        }
        System.out.println(count);
        System.out.println(targetWord);
    }
}