unordered_map<char, int> ladybug;
     int flag = 0;
     //counting frequency of character
     for(int i = 0; i< b.size(); i++){
        ladybug[b[i]]++;
     }
     
     //checking the count of the character greater than 1
     if(ladybug.size() > 1){
        for(int i = 0; i< ladybug.size(); i++){
            char c = i+ 65;
            if(ladybug[c]== 1 && c != '_') return "NO";
        }
     }
     
     //checking if any possible chance to switch 
     for(auto i : ladybug){
        if(i.first == '_'){flag = 1; break;}
     }
     
     // checking it is sorted or not if there is no chance to switch
     if(flag == 0){
        for(int i = 0; i< b.size();i++){
            if(b[i] == b[i+1] || b[i] == b[i-1]){
                flag = 1;
            }else{
                flag = 0;
                break;
            }
        }
     }
     
     return  flag == 0 ? "NO" : "YES";

		int count = 0;
		char[] chars = b.toCharArray();

		if (b.indexOf('_') >= 0)
			Arrays.sort(chars);

		for (int i = 1; i < chars.length; ++i) {
			if (chars[i] == '_')
				break;

			if (chars[i - 1] == chars[i]) {
				++count;
			} else if (count == 0) {
				count = -1;
				break;
			} else {
				count = 0;
			}

		}

		return count > 0 || chars[0] == '_' ? "YES" : "NO";

string happyLadybugs(string b) {
    vector<int> occ(26, 0);
    bool happy = true, underscore = false;
    b = "0"+b+"0";
    for(int i = 1; i < b.size()-1; i++){
        if(b[i] != '_' && b[i] != b[i-1] && b[i] != b[i+1]) happy = false;
        if(b[i] == '_') underscore = true;
        else occ[b[i] - 'A']++;
    }
    if(happy) return "YES";
    if(underscore && find(occ.begin(), occ.end(), 1) == occ.end()) return "YES";
    return "NO";
}

struct p {
  int cnt = 0;
  int lp = 0;
};

string happyLadybugs(string b) {
  
  map<char, p> m;

  bool right = true;
  int pos = 0;
  for(auto& a : b) {
    m[a].cnt += 1;
    if(a != '_' && m[a].lp > 0 &&  m[a].lp != pos-1)
      right = false;
    m[a].lp = pos;
    pos++;
  }
  
  for(auto& a : m){
    if(a.first != '_' && a.second.cnt < 2) {
      return "NO";
    }
  }
  
  if(right)
    return "YES ";

  if(m.count('_') == 0)
    if(m.size() == 1 && (*m.begin()).second.cnt > 1)
      return "YES ";
    else
      return "NO";
  else {
    if(m.size() == 2 && 
       (*m.begin()).second.cnt + (*m.begin()++).second.cnt == b.size())
      return "YES ";
  }

  return "YES";
}

/* All the ladybugs are possible to be made happy if there is at least one empty
 * cell (underscore) and there is no color with only one ladybug. First we check
 * if there is any color with only one ladybug. If so we print "NO". Then we
 * check if there is at least one empty cell. If not, the ladybugs must already
 * be happy without moving. If there isn't any empty cell to move the ladybugs
 * around we check if all the initial positions are happy. If not we print "NO".
 * If it passes the tests we print "YES". Either the ladybugs are happy or are
 * possible to be made. In order to determine if there is any color with only
 * one ladybug we need a frequency table to hold how many times each color
 * occurs in the string. You can use an array with a size of 26 each index
 * corresponding to one letter A-Z or a hashmap to store the frequencies of each
 * color.
 */

// WITH ARRAY
class Result {
  public static String happyLadybugs(String b) {
    String happyString = "YES";
    String notHappyString = "NO";
    boolean hasUnderScore = false;
    int[] freqTable =
        new int[26]; // To store frequency of ladybugs (A-Z). A' frequency is
                     // stored at int[0] and Z's at int[25]

    // Step 1: Count frequencies of each ladybug and check for underscores
    for (char c : b.toCharArray()) {
      if (c == '_') {
        hasUnderScore = true; // Flag to track if there's at least one
                              // underscore
      } else {
        freqTable[c - 'A']++;
      }
    }

    // Step 2: Check if there's any ladybug with only 1 occurrence
    if (hasSingleOccurence(freqTable)) {
      return notHappyString;
    }

    // Step 3: If there are no underscores, check if the arrangement is already
    // happy
    if (!hasUnderScore && !isAlreadyHappy(b)) {
      return notHappyString;
    }

    // Otherwise happy
    return happyString;
  }

  // Method to check if any ladybug has only a single occurrence
  private static boolean hasSingleOccurence(int[] freq) {
    for (int i = 0; i < 26; i++) {
      if (freq[i] == 1) {
        return true;
      }
    }
    return false;
  }

  // Method to check if the string is already in a "happy" state (no
  // underscores)
  private static boolean isAlreadyHappy(String b) {
    for (int i = 0; i < b.length(); i++) {
      char current = b.charAt(i);
      if ((i > 0 && b.charAt(i - 1) == current)
          || (i < b.length() - 1 && b.charAt(i + 1) == current)) {
        continue;
      }
      return false; // found an unhappy ladybug
    }
        return true;
  }
}

    // WITH HASHMAP

    class Result {
      /*
       * Complete the 'happyLadybugs' function below.
       *
       * The function is expected to return a STRING.
       * The function accepts STRING b as parameter.
       */

      public static String happyLadybugs(String b) {
        String happyString = "YES";
        String notHappyString = "NO";
        boolean hasUnderScore = false;
        Map<Character, Integer> freqTable = new HashMap<>();

        // Step 1: Count frequencies of each ladybug and check for underscores
        for (char c : b.toCharArray()) {
          if (c == '_') {
            hasUnderScore =
                true; // Flag to track if there's at least one underscore
          } else {
            freqTable.put(c, freqTable.getOrDefault(c, 0) + 1);
          }
        }

        // Step 2: Check if there's any ladybug with only 1 occurrence
        if (hasSingleOccurence(freqTable)) {
          return notHappyString;
        }

        // Step 3: If there are no underscores, check if the arrangement is
        // already happy
        if (!hasUnderScore && !isAlreadyHappy(b)) {
          return notHappyString;
        }

        // Otherwise happy
        return happyString;
      }

      // Method to check if any ladybug has only a single occurrence
      private static boolean hasSingleOccurence(Map<Character, Integer> freq) {
        for (char key : freq.keySet()) {
          // If a character is not '_' and occurs only once, it's impossible to
          // make them happy
          if (freq.get(key) == 1) {
            return true;
          }
        }
        return false;
      }

      // Method to check if the string is already in a "happy" state (no
      // underscores)
      private static boolean isAlreadyHappy(String b) {
        for (int i = 0; i < b.length(); i++) {
          char current = b.charAt(i);
          if ((i > 0 && b.charAt(i - 1) == current)
              || (i < b.length() - 1 && b.charAt(i + 1) == current)) {
            continue;
          }
          return false; // found an unhappy ladybug
        }
        return true;
      }
    }