import java.io.; import java.util.; import java.util.stream.*;

class Result {

public static String biggerIsGreater(String w) {
    char[] chars = w.toCharArray();
    int i = chars.length - 2;

    // Step 1: Find the first character that is smaller than its next character from the end
    while (i >= 0 && chars[i] >= chars[i + 1]) {
        i--;
    }

    if (i < 0) {
        return "no answer";
    }

    // Step 2: Find the smallest character on the right of i that is greater than chars[i]
    int j = chars.length - 1;
    while (chars[j] <= chars[i]) {
        j--;
    }

    // Step 3: Swap them
    char temp = chars[i];
    chars[i] = chars[j];
    chars[j] = temp;

    // Step 4: Reverse the suffix starting at i + 1
    int left = i + 1, right = chars.length - 1;
    while (left < right) {
        temp = chars[left];
        chars[left] = chars[right];
        chars[right] = temp;
        left++;
        right--;
    }

    return new String(chars);
}

}

public class Solution { public static void main(String[] args) throws IOException { BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

    int T = Integer.parseInt(bufferedReader.readLine().trim());

    IntStream.range(0, T).forEach(TItr -> {
        try {
            String w = bufferedReader.readLine();
            String result = Result.biggerIsGreater(w);
            bufferedWriter.write(result);
            bufferedWriter.newLine();
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    });

    bufferedReader.close();
    bufferedWriter.close();
}

}

`string biggerIsGreater(string w) { int index = 0; int decStart = -1; int swapIndex = -1; while (index < w.length()) { // Increasing if (index + 1 < w.length() && w[index] < w[index + 1]) { decStart = index + 1; swapIndex = index; } // Decreasing, we found a new minimum that is smaller else if (decStart != -1 && w[index] <= w[decStart] && w[index] > w[swapIndex]) { // If the new character is greater than the character to be swapping decStart = index; } index++; }

if (decStart == -1) {
    return "no answer";
}

string descending = w.substr(decStart);
reverse(descending.begin() + 1, descending.end());
if (swapIndex + 1 < decStart) {
    reverse(w.begin() + swapIndex + 1, w.begin() + decStart);
}
w.erase(decStart);
w.insert(swapIndex, descending);
return w;`

}

solution in scala

def biggerIsGreater(w: String): String = {
  var i = w.length - 1
  val charMap = mutable.Map[Char, Int]()
  var replacePos: Option[Int] = None
  while(i >= 0 && replacePos.isEmpty){
    charMap(w(i)) = i
    val nextLargest = charMap
      .filter { case (k, _) => k > w(i) }
      .minByOption { case (k, _) => k }
    replacePos = nextLargest match{
      case None => {
        i = i - 1
        None
      }
      case Some(s) => Some(charMap(s._1))
    }
  }
  replacePos match{
    case None => "no answer"
    case Some(s) => {
      val switched = w.updated(s, w(i)).updated(i, w(s))
      // sort after the initial switch to efficiently arrive at the smallest possible substring
      val (prefix, suffix) = switched.splitAt(i + 1)
      val sortedSuffix = suffix.sorted
      prefix + sortedSuffix
    }
  }
}

Here is my Python solution!

def biggerIsGreater(w):
    if "".join(sorted(list(w), reverse=True)) == w:
        return "no answer"
    i1 = len(w) - 2
    while w[i1] >= w[i1 + 1]:
        i1 -= 1
    i2 = len(w) - 1
    while w[i2] <= w[i1]:
        i2 -= 1
    left = list(w)[:i1]
    changed = list(w[i1:])
    changed[0], changed[i2 - i1] = changed[i2 - i1], changed[0]
    middle = changed[0:1]
    right = changed[1:]
    right.sort()
    return "".join(left + middle + right)