Sort by

recency

|

997 Discussions

|

  • + 0 comments
    solution in Javascript:
    function biggerIsGreater(w) {
        let s = w.split("");
        let index = -1;
        let n = w.length;
        
        for(let i = n-2; i>=0;i--){
            if(s[i] < s[i+1]){
                index = i;
                break;
            }
        }
        
        if(index === -1){
            return "no answer"
        }else{
            for(let i = n-1; i> index; i--){
                if(s[i] > s[index]){
                    swap(index, i, s);
                    break;
                }
            }
            reverse(index+1, n-1, s)
        }
        
        return s.join("");
        
        function swap(w1, w2, s){
            let temp = s[w1];
            s[w1] = s[w2];
            s[w2] = temp;
        }
    
        function reverse(start, end, s){
            while(start <= end){
                swap(start, end, s);
                start++;
                end--;
            }
        }
    }
    
  • + 0 comments

    `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;`
    

    }

  • + 0 comments

    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
        }
      }
    }
    
  • + 0 comments

    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)
    
  • + 0 comments

    Here is problem solution in Python, Java, C++, C and Javascript - https://programmingoneonone.com/hackerrank-bigger-is-greater-problem-solution.html