Sort Characters By Frequency

                                            
class Solution {
public:
    string frequencySort(string s) {
        unordered_map<char, int> freq;
        for (char c : s) {
            freq[c]++;
        }

        auto comp = [&](char a, char b) {
            return freq[a] != freq[b] ? freq[a] > freq[b] : a < b;
        };

        sort(s.begin(), s.end(), comp);

        return s;
    }
};

                                            
class Solution {
    public String frequencySort(String s) {
        Map<Character, Integer> map = new HashMap<>();
        for (char c : s.toCharArray()) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        
        PriorityQueue<Character> maxHeap = new PriorityQueue<>((a, b) -> map.get(b) - map.get(a));
        maxHeap.addAll(map.keySet());
        
        StringBuilder result = new StringBuilder();
        while (!maxHeap.isEmpty()) {
            char current = maxHeap.poll();
            int count = map.get(current);
            for (int i = 0; i < count; i++) {
                result.append(current);
            }
        }
        
        return result.toString();
    }
}

                                            
class Solution(object):
    def frequencySort(self, s):
        """
        :type s: str
        :rtype: str
        """
        char_freq = collections.Counter(s)
        sorted_chars = sorted(char_freq.keys(), key=lambda x: (-char_freq[x], x))
        result = ''.join([char * char_freq[char] for char in sorted_chars])
        
        return result

                                            
public class Solution {
    public string FrequencySort(string s) {
        Dictionary<char, int> frequency = new Dictionary<char, int>();
        foreach (char c in s)
        {
            if (frequency.ContainsKey(c))
            {
                frequency[c]++;
            }
            else
            {
                frequency[c] = 1;
            }
        }
        
        StringBuilder sb = new StringBuilder();
        foreach (var item in frequency.OrderByDescending(x => x.Value))
        {
            sb.Append(new string(item.Key, item.Value));
        }
        
        return sb.ToString();
    }
}

                                            
/**
 * @param {string} s
 * @return {string}
 */
const frequencySort = (s) => {
    const charMap = {};
    const sortedChars = [];
    let result = '';

    for (let char of s) {
        charMap[char] = (charMap[char] || 0) + 1;
    }

    sortedChars.push(...Object.keys(charMap).sort((a, b) => charMap[b] - charMap[a]));

    sortedChars.forEach(char => {
        result += char.repeat(charMap[char]);
    });

    return result;
};

                                            
function frequencySort(s: string): string {
    const charMap: { [key: string]: number } = {};
    
    for (let char of s) {
        if (char in charMap) {
            charMap[char]++;
        } else {
            charMap[char] = 1;
        }
    }
    
    const sortedChars = Object.keys(charMap).sort((a, b) => charMap[b] - charMap[a]);
    
    let result = '';
    for (let char of sortedChars) {
        result += char.repeat(charMap[char]);
    }
    
    return result;
};

                                            
class Solution {
    /**
     * @param String $s
     * @return String
     */
    function frequencySort($s) {
        $map = [];
        $result = '';

        for ($i = 0; $i < strlen($s); $i++) {
            $map[$s[$i]] = isset($map[$s[$i]]) ? $map[$s[$i]] + 1 : 1;
        }

        arsort($map);

        foreach ($map as $char => $count) {
            $result .= str_repeat($char, $count);
        }

        return $result;
    }
}

                                            
class Solution {
    func frequencySort(_ s: String) -> String {
        var dict: [Character: Int] = [:]
        
        for char in s {
            dict[char, default: 0] += 1
        }
        
        let sortedChars = dict.sorted { $0.value > $1.value }
        
        var result = ""
        for (char, count) in sortedChars {
            result += String(repeating: char, count: count)
        }
        
        return result
    }
}

                                            
class Solution {
    fun frequencySort(s: String): String {
        val charCount = s.groupingBy { it }.eachCount()
        val sortedChars = charCount.keys.sortedByDescending { charCount[it] }

        val result = StringBuilder()
        for (char in sortedChars) {
            result.append(char.toString().repeat(charCount[char] ?: 0))
        }

        return result.toString()
    }
}

                                            
class Solution {
  String frequencySort(String s) {
    Map<String, int> charFrequency = {};
    
    for (int i = 0; i < s.length; i++) {
      charFrequency[s[i]] = (charFrequency[s[i]] ?? 0) + 1;
    }
    
    List<String> uniqueChars = charFrequency.keys.toList();
    uniqueChars.sort((a, b) => charFrequency[b]!.compareTo(charFrequency[a]!));
    
    StringBuffer sb = StringBuffer();
    for (String char in uniqueChars) {
      sb.write(char * charFrequency[char]!);
    }
    
    return sb.toString();
  }
}

                                            
func frequencySort(s string) string {
    // Count frequency of each character
    freqMap := make(map[rune]int)
    for _, char := range s {
        freqMap[char]++
    }

    // Sort characters by frequency
    sortedChars := make([]rune, 0, len(freqMap))
    for char := range freqMap {
        sortedChars = append(sortedChars, char)
    }
    sort.Slice(sortedChars, func(i, j int) bool {
        return freqMap[sortedChars[i]] > freqMap[sortedChars[j]]
    })

    // Build the sorted string
    var result strings.Builder
    for _, char := range sortedChars {
        for i := 0; i < freqMap[char]; i++ {
            result.WriteRune(char)
        }
    }

    return result.String()
}

                                            
# @param {String} s
# @return {String}
def frequency_sort(s)
    char_freq = s.chars.group_by(&:itself).transform_values(&:count)
    sorted_chars = char_freq.sort_by { |char, freq| -freq }.map { |char, freq| char * freq }
    sorted_chars.join
end

                                            
use std::collections::HashMap;

impl Solution {
    pub fn frequency_sort(s: String) -> String {
        let mut char_count: HashMap<char, i32> = HashMap::new();
        
        for c in s.chars() {
            *char_count.entry(c).or_insert(0) += 1;
        }
        
        let mut sorted_chars: Vec<char> = char_count.keys().map(|&c| c).collect();
        sorted_chars.sort_by_key(|&c| char_count[&c]);
        sorted_chars.reverse();
        
        let mut res = String::new();
        for c in sorted_chars {
            for _ in 0..char_count[&c] {
                res.push(c);
            }
        }
        
        res
    }
}

                                            
defmodule Solution do
  @spec frequency_sort(s :: String.t) :: String.t
  def frequency_sort(s) do
    s
    |> String.graphemes()
    |> Enum.group_by(& &1)
    |> Enum.sort_by(fn {_, values} -> -length(values) end)
    |> Enum.reduce("", fn {_, vals}, acc -> acc <> Enum.join(vals, "") end)
  end
end

To solve this coding challenge: The main goal is to sort the characters in a string based on their frequency, from the most frequent to the least frequent. If there are characters with the same frequency, their relative order doesn't matter as long as they appear together. This task is simplified by breaking it down into a few steps: counting the frequency of each character, sorting characters based on their frequencies, and finally building the resulting string based on these sorted characters.

# Explanation:

Count the Frequency of Each Character:

We first need to determine how many times each character appears in the string. This can be done using a dictionary or specialized data structures like
Counter

from the
collections

module in Python.

Sort Characters by Frequency:

Once we have the frequency count, the next step is to sort the characters based on these frequencies. We want the characters with the highest frequencies to come first. A convenient way to achieve this is by using a sorting function that can handle custom keys.

Build the Resulting String:

After sorting, construct the output string by repeating each character based on its frequency count.

Step-by-Step Explanation:

Step 1: Count the Frequency of Each Character

Initialize a dictionary to keep track of character frequencies.
Iterate over each character in the input string and update the frequency count in the dictionary.

Step 2: Sort Characters by Frequency

Extract characters from the frequency dictionary and sort them by frequency in descending order.
This can be done using a sorting function where the key is the frequency of each character.

Step 3: Build the Resulting String

Iterate over the sorted list of characters.
For each character, append it to the result string as many times as its frequency count.

Detailed Steps in Pseudocode

Initialization of Data Structures:

                                            
# Initialize a dictionary to store the frequency counts of characters
character_frequency = {}

# Traverse each character in the input string
for each character in input_string:
# If the character is already in the dictionary, increment its count
if character is in character_frequency:
character_frequency[character] = character_frequency[character] + 1
# Otherwise, add the character to the dictionary with a count of 1
else:
character_frequency[character] = 1

Sorting Characters by Frequency:

                                            
# Extract characters and their frequencies from the dictionary into a list
character_list = list of (character, frequency) from each item in character_frequency

# Sort the list based on the frequency in descending order
# If frequencies are the same, maintain any order between those characters
sorted_character_list = sort character_list by frequency in descending order

Building the Resulting String:

                                            
# Initialize an empty string to build the result
result_string = ""

# Traverse the sorted list of characters
for each (character, frequency) in sorted_character_list:
    # Append the character to the result string, repeated by its frequency
    result_string = result_string + (character * frequency)

Summarizing the steps, here’s the full pseudocode with comments:

                                            
# Initialize a dictionary to store the frequency counts of characters
character_frequency = {}

# Traverse each character in the input string
for each character in input_string:
    # If the character is already in the dictionary, increment its count
    if character is in character_frequency:
        character_frequency[character] = character_frequency[character] + 1
    # Otherwise, add the character to the dictionary with a count of 1
    else:
        character_frequency[character] = 1

# Extract characters and their frequencies from the dictionary into a list
character_list = list of (character, frequency) from each item in character_frequency

# Sort the list based on the frequency in descending order
# If frequencies are the same, maintain any order between those characters
sorted_character_list = sort character_list by frequency in descending order

# Initialize an empty string to build the result
result_string = ""

# Traverse the sorted list of characters
for each (character, frequency) in sorted_character_list:
    # Append the character to the result string, repeated by its frequency
    result_string = result_string + (character * frequency)

# Output the resulting string
return result_string

This pseudocode breaks down the problem into manageable steps, ensuring that characters are sorted by frequency and concatenated correctly to form the final output string.