字符统计__牛客网

Java

想找工作的张先生

import java.util.HashMap;

import java.util.Map;

import java.util.Scanner;

import java.util.Set;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

String str = in.nextLine();

Map<Character,Integer> map = new HashMap<>();

for(int i = 0;i<str.length();i++){

Character s = str.charAt(i);

if(map.containsKey(s)){

map.put(s,map.get(s)+1);

}else{

map.put(s,1);

}

Object[] chars= (map.keySet().toArray());

for(int i = 0;i<chars.length-1;i++){

int index = i;

for(int j = i+1;j<chars.length;j++){

char c = (char)chars[j];

if(map.get(c ) > map.get(chars[index])

|| (map.get(c ) == map.get(chars[index])

&& c < (char)chars[index])){

index = j;

}

if(index != i){

char temp = (char)chars[i];

chars[i] = chars[index];

chars[index] = temp;

}

for(Object ch:chars){

System.out.print(ch);

}

发表于 2025-04-11 15:01:40 回复(0)

Java

杰克2002

思路大概是运用treemap的自动排序把字符串排序数字-》大写——》小写，然后第一遍循环找value最大的值，第二遍循环从头（已排序）找value=max的key，输出那个key，然后map.remove把那个项删了，在前面用

while(!ts.isEmpty())判断是否还有，我的感觉是思路清楚，但是实现有些复杂

     Scanner sc=new Scanner(System.in);
        String str= sc.nextLine();
        TreeMap<Character,Integer> ts=new TreeMap<>();
        for (int i = 0; i < str.length(); i++) {
          ts.put(str.charAt(i),ts.getOrDefault(str.charAt(i),0)+1);
          }
        int max=0;
        while(!ts.isEmpty()) {
            Set<Character> characters = ts.keySet();
            Object[] array = characters.toArray();
            for (int i=0;i<array.length;i++) {
                if (ts.get(array[i]) >= max) {
                    max = ts.get(array[i]);
                }
            }
            for (int i=0;i<array.length;i++)  {
                if (ts.get(array[i]) == max) {
                    System.out.print(array[i]);
                    ts.remove(array[i]);
                }

            }
            max=0;
        }

发表于 2025-03-13 00:11:29 回复(0)

Java

牛客160935469号

import java.io.*;
import java.util.HashMap;
import java.util.stream.Collectors;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        HashMap<Character, Integer> h = new HashMap<>();
        int c;
        while ((c = System.in.read()) != '\n') {
            if (h.containsKey((char)c)) {
                h.put((char)c, h.get((char)c)+1);
            } else {
                h.put((char)c, 1);
            }
        }
        List<Character> s = h.keySet().stream().sorted((a, b)->{
            if (h.get(a) == h.get(b)) return a - b;
            return h.get(b)-h.get(a);
        }).collect(Collectors.toList());
        for (char t: s) {
            System.out.print(t);
        }
    }
}

发表于 2024-10-03 16:10:18 回复(0)

Java

想去广东逛gai的里根说等下个版本吧

看了大家的代码，感觉我这个思路挺独特，测试用例也过了
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        TreeMap<Character, Integer> map = new TreeMap<>();
        for (char c : str.toCharArray()) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        Integer[] arr = map.values().toArray(new Integer[0]);
        Arrays.sort(arr, Comparator.reverseOrder());
        StringBuilder result = new StringBuilder();
        for (Integer count : arr) {
            for (Map.Entry<Character, Integer> entry : map.entrySet()) {
                Integer value = entry.getValue();
                Character key = entry.getKey();
                if (value.equals(count) && !result.toString().contains(String.valueOf(key))) {
                    result.append(key);
                }
            }
        }
        System.out.println(result);
    }
}

发表于 2024-08-24 17:51:34 回复(0)

Java

欢哥你是大神

import java.util.Scanner;
import java.util.TreeMap;
import java.util.Arrays;
import java.util.Map;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        //1.TreeMap获取字符及数量，默认按字符升序排列
        TreeMap<Character, Integer> tm = new TreeMap();
        for (int i = 0; i < s.length(); i++) {
            if (tm.containsKey(s.charAt(i))) {
                int count = tm.get(s.charAt(i));
                tm.put(s.charAt(i), ++count);
            } else {
                tm.put(s.charAt(i), 1);
            }
        }
        //2.每次取出第一个出现次数最大值字符，拼接到sb中
        StringBuilder sb = new StringBuilder("");
        //Arrays.sort方法也可以实现，但是编译器不支持自定义排序函数使用
        while (!tm.isEmpty()) {
            int max = getMax(tm);
            for(Map.Entry<Character, Integer> entry :tm.entrySet()){
                if(entry.getValue()==max){
                    char c=entry.getKey();
                    sb.append(c);
                    //遍历过该字符，删除
                    tm.remove(c);
                    break;
                }
            }
        }
        System.out.print(sb.toString());

    }
    public static int getMax(TreeMap<Character, Integer> tm) {
        int max = 0;
        for (int num : tm.values()) {
            if (num > max) {
                max=num;
            }
        }
        return max;
    }
}

发表于 2024-03-28 15:33:58 回复(0)

Java

觉醒了的刚子很想奋斗

我是使用其他class来辅助的

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    public static void solution(String inputStr) {
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String inputStr = in.nextLine();
            Map<Character, Integer> charNumMap = new HashMap<>();
            for(int i = 0; i < inputStr.length(); i ++) {
                char curChar = inputStr.charAt(i);
                if(charNumMap.containsKey(curChar)) {
                    charNumMap.put(curChar, charNumMap.get(curChar) + 1);
                } else {
                    charNumMap.put(curChar, 1);
                }
            }
             Set<Node> nodeSet = new TreeSet<>();
            for(Map.Entry<Character, Integer> entry : charNumMap.entrySet()) {
                Character key = entry.getKey();
                Integer value = entry.getValue();
                nodeSet.add(new Node(key, value));
            }
            for(Node item : nodeSet) {
                //System.out.println(item.getElement() + " : " + item.getNumber());
                System.out.print(item.getElement());
            }
        }
    }  
}

class Node implements Comparable {

           private char element;
           private int number;
           
            public Node(char element, int number) {
                this.element = element;
                this.number = number;
            }

           public char getElement() {
                return this.element;
           }
           public int getNumber() {
                return this.number;
           }

        //    @Override
        //    public int hashCode() {
        //         return 11111;
        //    }

        //    @Override
        //    public boolean equals(Object obj) {
        //        Node inputN = (Node)obj;
        //        if(this.getElement() == inputN.getElement() ) {
        //            return true;
        //        }
        //        return false;
        //    }

           @Override
           public int compareTo(Object n) {
                Node inputN = (Node)n;
                if(this.getNumber() > inputN.getNumber()) {
                    return -1;
                } else if(this.getNumber() == inputN.getNumber()) {
                    if(this.getElement() > inputN.getElement()) {
                        return 1;
                    } else if(this.getElement() == inputN.getElement()) {
                        return 0;
                    } else {
                        return -1;
                    }
                } else {
                    return 1;
                }
           }
    }

编辑于 2024-01-17 14:21:21 回复(0)

Java

牛客269675522号

尽量用流式处理和lambda提高可读性

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 的区别
        String str = in.nextLine();
        char[] arr = str.toCharArray();
        Map<Character, Integer> map = new HashMap<Character, Integer>();
        for (char c : arr) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        List<Map.Entry<Character, Integer>> entryList = map.entrySet().stream()
                .sorted((o1, o2) -> Character.compare(o1.getKey(), o2.getKey()))
                .sorted((o1, o2) -> Integer.compare(o2.getValue(), o1.getValue()))
                .collect(Collectors.toList());
        entryList.forEach(entry -> System.out.print(entry.getKey()));
    }
}

编辑于 2024-01-01 11:28:26 回复(0)

Java

牛客624030975号

import java.util.*;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class emptyBowl {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        char[] array = s.toCharArray();
        int[] a = new int[128];
        for (char c : array) {
            a[(int) c]++;
        }
        int max = s.length();
        while (max > 0) {
            for (int i = 0; i < a.length; i++) {
                if (a[i] == max) {
                    System.out.print((char) i);
                }
            }
            max--;
        }
    }
}

编辑于 2023-12-07 02:53:39 回复(0)

Java

Kili_66

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        Map<Character, Integer> map = new HashMap();
        for (int i = 0; i < s.length(); i++) {
            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
        }
        List<Map.Entry<Character, Integer>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, (o1, o2)-> {
            if (o1.getValue() != o2.getValue()) {
                return o2.getValue() - o1.getValue();
            } else {
                return o1.getKey().compareTo(o2.getKey());
            }
        });
        list.forEach( e -> System.out.print(e.getKey()));
    }
}

发表于 2023-11-28 22:20:34 回复(0)

Java

牛客106397800号

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();

        // 统计每个字符的次数
        HashMap<Character, Integer> map = new HashMap<>();
        // 遍历
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            map.put(c, map.getOrDefault(c, 0) + 1);
        }

        // 业务场景为按照key排序，并统计次数
        TreeMap<Integer, TreeSet<Character>> treeMap = new TreeMap<>
        (new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 按照次数降序
                return o2.compareTo(o1);
            }
        });

        // 放入treeMap中排序，按照次数降序，相同次数的字符，按照升序排序
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            Integer value = entry.getValue();
            Character key = entry.getKey();
            TreeSet<Character> characters = treeMap.get(value);

            if (characters == null) {
                TreeSet<Character> treeSet = new TreeSet<>();
                treeSet.add(key);
                treeMap.put(value, treeSet);
            } else {
                characters.add(key);
            }
        }

        // 打印结果
        for (Map.Entry<Integer, TreeSet<Character>> entry : treeMap.entrySet()) {
            Integer key = entry.getKey();
            TreeSet<Character> value = entry.getValue();
            for (Character character : value) {
                System.out.print(character);
            }
        }
    }
}

发表于 2023-08-15 16:47:44 回复(0)

Java

失落的小章鱼

import java.util.HashMap;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String source = sc.nextLine();
        HashMap<Character, Integer> charNum = new HashMap<>();
        for (char c : source.toCharArray()) {
            if (charNum.containsKey(c)) {
                charNum.put(c, charNum.get(c) + 1);
            } else {
                charNum.put(c, 1);
            }
        }
        TreeMap<Integer, TreeSet<Character>> statisticChars = new TreeMap<>((o1, o2) -> o2-o1);
        charNum.forEach((character, num) -> {
            if (statisticChars.containsKey(num)) {
                statisticChars.get(num).add(character);
            } else {
                TreeSet<Character> value = new TreeSet<>();
                value.add(character);
                statisticChars.put(num, value);
            }
        });

        for (TreeSet<Character> value : statisticChars.values()) {
            for (Character character : value) {
                System.out.print(character);
            }
        }
    }
}

发表于 2023-08-10 14:03:58 回复(0)

Java

练习时长两年半的太平湖水怪很理智

import java.io.*;

public class Main {
    public static void main(String[] agrs) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        while ((str = br.readLine()) != null) {
            int[] arr = new int[128];
            for (int i = 0; i < str.length(); i++) {
                char ch = str.charAt(i);
                // 如果某个字符出现，则将该字符ASCII码值作为下标的数组元素值+1
                arr[(int)ch]++;
            }
            int max = 0;
            // 寻找最大次数
            for (int i = 0; i < arr.length; i++) if (arr[i] > max) max = arr[i];
            StringBuilder sb = new StringBuilder();
            while (max > 0) {
                // 寻找数组中值为max的元素，若找到则将该值对应的下标转换为char类型，然后拼接
                // 因为下标即为ASCII码值，所以可以直接将下标转换为char类型
                // 因为是从i=0的下标开始递增遍历,所以如果对出现次数相同的字符,会按按ASCII码的升序拼接
                for (int i = 0; i < arr.length; i++) if (arr[i] == max) sb.append((char)i);
                max--;
            }
            System.out.println(sb.toString());
        }
    }
}

发表于 2023-07-18 11:49:47 回复(0)

Java

在泡池子的小饼干很想被叫靓仔

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

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String str = sc.nextLine();
            HashMap<Character, Integer> map = new HashMap<>();
            //把 字符-出现次数 放入HashMap中
            for (char ch : str.toCharArray()) {
                map.put(ch, map.getOrDefault(ch, 0) + 1);
            }
            // 再把字符放入ArrayList中，自定义比较器进行sort
            ArrayList<Character> chList = new ArrayList<>(map.keySet());
            Collections.sort(chList, new Comparator<Character>() {
                public int compare(Character c1, Character c2) {
                    int num = map.get(c2)-map.get(c1);
                    int num2 = num==0?c1 - c2:num;
                    return num2;
                }
            });
            //输出排序后的字符
            for (Character ch : chList) {
                System.out.print(ch.toString());
            }
            System.out.println();
        }
        sc.close();
    }
}

发表于 2023-07-02 19:26:15 回复(1)

Java

牛客604637229号

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

// 注意 hasNext 和 hasNextLine 的区别

while (in.hasNext()) { // 注意 while 处理多个 case

String a = in.next();

char[] chars = a.toCharArray();

TreeMap<Character,Integer> treeMap = new TreeMap<Character,Integer>();

for(int i=0;i<chars.length;i++){

char c= chars[i];

if(treeMap.containsKey(c)){

treeMap.put(c,treeMap.get(c)+1);

}else{

treeMap.put(c,1);

}

ArrayList<TreeMap<Character,Integer>> list = new ArrayList<TreeMap<Character,Integer>>();

for(Map.Entry<Character,Integer> entry:treeMap.entrySet()){

TreeMap<Character,Integer> temp = new TreeMap<Character,Integer>();

temp.put(entry.getKey(),entry.getValue());

list.add(temp);

}

list.sort(new Comparator<TreeMap<Character,Integer>>(){

@Override

public int compare(TreeMap<Character,Integer> o1,TreeMap<Character,Integer> o2){

return o2.lastEntry().getValue()-o1.lastEntry().getValue();

}

});

StringBuffer bf = new StringBuffer();

for(TreeMap<Character,Integer> mm:list){

bf.append(mm.firstEntry().getKey());

}

System.out.println(bf.toString());

}

发表于 2023-04-16 23:25:43 回复(0)

Java

不给offer不改名😡

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        int n = str.length();
        HashMap<Character, Integer> map = new HashMap<>();
        for(int i = 0; i < n; i++){
            Character c = str.charAt(i);
            if(!map.containsKey(c))
                map.put(c, 1);
            else{
                map.put(c, map.get(c) + 1);
            }
        }
        Queue<Map.Entry<Character, Integer>> queue = new PriorityQueue<Map.Entry<Character, Integer>>((a, b) -> {
            if(a.getValue() > b.getValue())
                return -1;
            else if(a.getValue() < b.getValue())
                return 1;
            else if(a.getKey() < b.getKey())
                return -1;
            else
                return 1;
        });
        for(Map.Entry<Character, Integer> entry : map.entrySet()){
            queue.offer(entry);
        }
        StringBuffer buffer = new StringBuffer();
        while(!queue.isEmpty()){
            buffer.append(queue.poll().getKey());
        }
        System.out.println(buffer.toString());
    }
}

发表于 2023-04-06 20:59:36 回复(0)

Java

不放弃的放鸽子能手很帅气

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String str = in.next();
            //字符串转为字节数组
            char[] strChar = str.toCharArray();
            //int数组，下标用于表示ascll值，值代表出现的个数
            int[] chars = new int[129];
            //遍历字符数组，统计int数组下标代表的字符出现次数
            for (char c : strChar) {
                chars[(int)c]++;
            }
            //代表出现最多的一个字符出现的次数
            int max = 0;
            //遍历int数组出现最多的一个字符出现的次数
            for (int i = 0; i < chars.length; i++) {

                if (chars[i] > max)
                    max = chars[i];
            }
            StringBuilder sb = new StringBuilder();

            while (max != 0) {
                //下标(即ASCII值)从小到大遍历，保证了【如果统计的个数相同，则按照ASCII码由小到大排序输出。】的要求
                for (int i = 0; i < chars.length; i++) {
                    if (chars[i] == max)
                        sb.append((char)i);
                }
                max--;
            }
            System.out.println(sb.toString());
        }
    }
}

发表于 2023-03-17 12:50:04 回复(0)

Java

Protein1206

import java.util.Comparator;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            TreeMap<Character, Integer> map = new TreeMap<>();
            for (char c : in.next().toCharArray()) {
                map.put(c, map.getOrDefault(c, 0) + 1);
            }
            map.entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).map(Map.Entry::getKey).forEach(System.out::print);
        }
    }
}

发表于 2023-03-08 17:08:19 回复(1)

字符统计

输入描述:

输出描述:

输入

输出

说明

问题信息

热门推荐

通过挑战的用户

相关试题