def find_smallest_char_larger(s, idx):
    char_compare = s[idx]
    sorted_chars = sorted(s[(idx + 1):])
    for char in sorted_chars:
        if char > char_compare:
            i = s.index(char, idx)
            return i
    return None
    
def biggerIsGreater(w):
    # Write your code here
    w_list = list(w)
    
    for idx in reversed(range(0, len(w) - 1)):
        char_i_to_swap = find_smallest_char_larger(w_list, idx)
        if char_i_to_swap is not None:
            w_list[char_i_to_swap], w_list[idx] = w_list[idx], w_list[char_i_to_swap]
            w_list[(idx + 1):] = sorted(w_list[(idx + 1):])
            return ''.join(w_list)
    
    return 'no answer'

public static String biggerIsGreater(String w) {
        char[] charArray = w.toCharArray();
        int n = charArray.length;

        // Step 1: Find the rightmost character that is smaller than its next character
        int index = -1;
        for (int i = n - 2; i >= 0; i--) {
            if (charArray[i] < charArray[i + 1]) {
                index = i;
                break;
            }
        }

        // If no such character exists, it's the last permutation
        if (index == -1) {
            return "no answer";
        }

        // Step 2: Find the smallest character on the right of `index` that is larger than charArray[index]
        int switchIndex = -1;
        for (int i = n - 1; i > index; i--) {
            if (charArray[i] > charArray[index]) {
                switchIndex = i;
                break;
            }
        }

        // Step 3: Swap the characters at `index` and `switchIndex`
        char temp = charArray[index];
        charArray[index] = charArray[switchIndex];
        charArray[switchIndex] = temp;

        // Step 4: Sort the substring after `index` to get the next lexicographical order
        Arrays.sort(charArray, index + 1, n);

        return new String(charArray);
    }

def biggerIsGreater(w):
    # i is the index of the element on the right hand-side
    index = None
    for i in range(len(w)-1, -1, -1): 
        w_list = sorted(list(w[i:]))
        w_list.reverse()
        sorted_w = ""
        for char in w_list:
            sorted_w += char
        if sorted_w != w[i:]:
            index = i
            break
    
    if index is None:
        return "no answer"
    
    smallest_bigger = None
    for i in w[index:]:
        if i > w[index] and (smallest_bigger is None or i < smallest_bigger):
            smallest_bigger = i
    w_list = list(w[index + 1:])
    w_list.remove(smallest_bigger)
    w_list.append(w[index])
    w_list.sort()
    sorted_w = ""
    for char in w_list:
        sorted_w += char
    w = w[:index] + smallest_bigger + sorted_w
    return w