We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Algorithms
  3. Implementation
  4. Bigger is Greater
  5. Discussions

Bigger is Greater

Sort by

recency

|

982 Discussions

|

  • wifivop476
     + 0 comments

    Tip: A nice observation is that once we swap our pivot position and the character most to the right that is greater than our pivot, we can reverse the rest of the string after the pivot (instead of sort).

    This is because while we were finding the character to swap, we already ensured that the elements to the right of the pivot ARE smaller jacqueline tortorice, so it's descending order. That's why reversing after the pivot point works.

  • vutrantrung14821
     + 1 comment
    def next_permutation(n):
    digits = list(str(n))  
    i = len(digits) - 2
    while i >= 0 and digits[i] >= digits[i + 1]:
        i -= 1
    j = len(digits) - 1
    while digits[j] <= digits[i]:
        j -= 1
    digits[i], digits[j] = digits[j], digits[i]
    digits = digits[:i+1] + digits[i+1:][::-1]
    return int(''.join(digits))
def biggerIsGreater(s):
  s_new=''
  p=[]
  q=[]
  w_new=sorted(s)
  m_new=sorted(s,reverse=1)
  if ''.join(m_new)==s:
    return 'no answer'
  for i in enumerate(w_new):
    p.append(i[0]+1)
    q.append(i[1])
  for i in s:
    s_new+=str(p[q.index(i)])
    print(i,s_new,p[q.index(i)])
  a=''
  for i in str(next_permutation(int(s_new))):
    a+=q[int(i)-1]
  return a

  • lukelukemorrism1
     + 0 comments

    My general algorithm for solving this is as follows: Let's use "dkhc" as the driving example.

    1. Start looking from the right, and find the first pair of letters that is out of order. Here, 'd' and 'k' are out of order.
    2. Find the smallest letter to the right of the out-of-order letter that is greater than it. Here, 'h' is the smallest letter that is greater than 'd'.
    3. Swap those two letters. This gives us "hkdc".
    4. Finally, sort all the letters to the right of the original out-of-order index. Here, that means sorting "kdc" into "cdk". Altogether then, "hcdk" is the final answer.

  • fedecorallini
     + 0 comments

    Java solution

     public static String biggerIsGreater(String w) {
// Write your code here

  String[] strSplit = w.split("");

  for(int i = w.length() -1 ; i >= 0; i--){
      for(int j = w.length() -1 ; j > i; j--){
          if(strSplit[i].charAt(0) < strSplit[j].charAt(0)){

              StringBuilder stringBuilder = new StringBuilder(w.substring(j+1));
              StringBuilder stringBuilder2 = new StringBuilder(w.substring(i + 1,j));

              return w.substring(0, i) + 
              w.charAt(j) + 
              stringBuilder.reverse().toString() + 
              w.charAt(i) +
              stringBuilder2.reverse().toString();
          }
      }
  }

  return "no answer";

}

  • abdheshnayak
     + 0 comments

    golang:

    func biggerIsGreater(w string) string {
    str := strings.Split(w, "")

    s_len := len(str)

    for i := 1; i < len(str); i++ {

        curr_index := s_len - i - 1
        curr := str[curr_index]

        rest := str[curr_index+1:]

        sort.Slice(rest, func(i, j int) bool {
            return rest[i] < rest[j]
        })

        for j, v := range rest {
            if v > curr {
                initial := strings.Join(str[:curr_index], "")
                rest = append(rest[:j], rest[j:]...)

                rest[j] = curr

                sort.Slice(rest, func(i, j int) bool {
                    return rest[i] < rest[j]
                })

                return initial + v + strings.Join(rest, "")
            }
        }

    }

    return "no answer" 
}