This was helpful. Thanks!

very nice solution

good logic !!!

Try to solve in Java. Calculating all next lexicographical permutation using this logic. But Test#1, #2 says 4s Terminated due to time out. Any suggestion?

Too helpful! Thanxx! :-)

Helped :)

Super helpful! Learned something new today!

Nice and clear explanation!

thanks!! that was well explained

Best Explanantion! Learned something new!

very helpful, thanks

Thank you. This was so helpful and very cool.

wow! great explanation ,Thanks

Thank You! Something new everyday.

That was really helpful!! Got to learn a lot..thanks :)

great

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <limits.h>
using namespace std;


int main() {
    long long int t;
    cin>>t;
    while(t>0)
    {
        string s;
        cin>>s;
        string ss=s;
        int i=s.length()-1;
        int pivot;
        while(s[i-1]>=s[i]&&i>=0)
            i--;
        if(i!=0)
          {
            pivot=i-1;
            int min=INT_MAX;
            int index;
            for(int j=i;j<s.length();j++)
              {
                if(int(s[j])>int(s[pivot])&&min>int(s[j])){
                    min=s[j];
                    index=j;
                }
            }
           char temp=s[pivot];
            s[pivot]=s[index];
            s[index]=temp;
            sort(s.begin()+i,s.end());
            cout<<s<<endl;
        }
        else
            cout<<"no answer\n";
         t--;    
    }
        
    return 0;
}

In my code,testcase 1 and testcase 2 are showing segmentation fault can you tell me what is the reason.I have used the same concept as described in article.

Guys think about the logic for a few minutes before looking at this!

Great Tutorial

extremely helpful! thanks a lot!

thank you very much

I tried to implement same algorithm. But only got test0 and test3 successful. I have written following code. Where might I be wrong?

public static void main(String[] args) throws IOException{
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 
    int n = Integer.parseInt(br.readLine());
    String[] str = new String[n];
    for (int i =0; i<n;i++){
        str[i]=br.readLine();
    }
    //int n=6;
    //String[] str = {"ab","bb","hefg","dhck","dkhc","zzzayybbaa"};
    List<String> pLst=new ArrayList<String>();
    for(String s:str){
        char[] chars = s.toCharArray();
        List<Character> lst =toChList(chars);
        pLst.add(listToString(nextBigPerm(lst)));
    }
    for(int i=0;i<str.length;i++){
        System.out.println((pLst.get(i).equals(str[i]) || str[i].length()<2)?"no answer":pLst.get(i));
    }
}
private static List<Character> toChList(char[] chars){
    List<Character> ch = new ArrayList<Character>();
    for (char c: chars)
        ch.add(c);
    return ch;
}
private static List<Character> nextBigPerm(List<Character> lst){
    int pivot = 0;
    int swap = lst.size() - 1;
    if (swap ==0) return lst;
    for(int i=1;i<lst.size();i++){
        if (lst.get(i-1)<lst.get(i))
            pivot=i-1;
        if (lst.get(pivot)<lst.get(i))
            swap = i;
    }
    Collections.swap(lst,pivot,swap);
    Collections.sort(lst.subList(pivot+1,lst.size()));
    return lst;
}
private static String listToString(List<Character> lst){
    StringBuilder s = new StringBuilder();
    for(Character c:lst)
        s.append(c);
    return s.toString();
}

Thanks @devstarj this http://www.nayuki.io/page/next-lexicographical-permutation-algorithm could be posted in the topics for Java solution

Awesome! Love the hackerrank community.

very nice

Thanks it was very helpful

I love you

Thank you ...

Thanks for the logic! Great help.

for _ in range(int(input())):
    s = input()
    has_greater = False
    for i in range(len(s)-1)[::-1]:
        if ord(s[i]) < ord(s[i+1]):
            for j in range(i+1,len(s))[::-1]:
                if ord(s[i]) < ord(s[j]):
                    lis = list(s)
                    lis[i],lis[j]=lis[j],lis[i]
                    print("".join(lis[:i+1]+lis[i+1:][::-1]))
                    has_greater = True
                if has_greater == True:
                    break
        if has_greater == True:
            break
    if has_greater == False:
        print("no answer")

thanks for posting this algorithm. here's a python 3 solution based on this algorithm

this is a hell of a lot simpler then the nayuki page

http://stackoverflow.com/questions/1622532/algorithm-to-find-next-greater-permutation-of-a-given-string

Thanks a Lot.I didnt think that it is this much simple

Learnt new logic. Very helpful. Thanks!

That moment when your inital algorithm was exactly the same

Thank you so much.It really helped a lot.

Thank you so much!

Also remember to include the edge case where the length of the word is 1.

yeah !!! that taught me the algo!! thanks!1

Thank you so much!

I think there is problem in the algorithm, instead of reversing the subarray , it should be sorted.

good job,better than editorial!

nice one

Thanks for the blog

thanks. copied this solution and refactored a little bit.

    static String biggerIsGreater(String w) {
        char[] chars = w.toCharArray();
        return nextPermutation(chars)
            ? new String(chars)
            : "no answer";
    }
    static boolean nextPermutation(char[] array) {
        int i = getLastPeakIndex(array);
        if (i <= 0) // like "dcba", no answer
            return false;

        int j = getReplacementIndex(array, i - 1);

        swap(array, i-1, j);

        // Reverse the part on the right of i - 1 to make it as small as possible
        j = array.length - 1;
        while (i < j) {
            swap(array, i, j);
            i++;
            j--;
        }
        
        return true;
    }

    static int getLastPeakIndex(char[] chars){
        int i = chars.length - 1;
        while (i > 0 && chars[i - 1] >= chars[i])
            i--;
        return i;
    }

    static int getReplacementIndex(char[] chars, int givenIndex){
        int i = chars.length - 1;
        while (chars[i] <= chars[givenIndex])
            i--;
        return i;
    }

    static void swap(char[] chars, int a, int b){
        chars[a] ^= chars[b];
        chars[b] ^= chars[a];
        chars[a] ^= chars[b];
    }

thanks bro!! helpful..

thank so much :))

Hi,

I have created a tutorial for you all. have a look, i hope it will help you to solve the problem.

Here is the video explanation of my solution in O(n) time -

https://youtu.be/BMbeeB_57Pk

Here's my JS solution. I started from the end of the string and worked backwords until I found a character that is less than something previous:

    let a = `abcdefghijklmnopqrstuvwxyz`;
    let idVals = [[w.length-1, a.indexOf(w.charAt(w.length-1))]];

    for(let i = w.length-2; i >= 0; i--){
        let val = a.indexOf(w.charAt(i));

        if(val < idVals[idVals.length-1][1]){
            let sub = ``;

            for(let j = 0; j < idVals.length; j++){
                let id = idVals[j][0];

                if(val < idVals[j][1]){
                    let start = (i === 0) ? w.charAt(id) :
                    w.substring(0,i) + w.charAt(id);
                    sub += w.substring(i,id).split(``).sort().join(``);
                    console.log(sub);

                    return start + sub;
                }
                sub += w.charAt(id);
            }
        }
        idVals.push([i,val]);
    }
    return `no answer`;

Thanks great explanation

Very helpful article. Thanks!

very helpful.thanks!

Great solution!!!! I was trying from last two days and finally found this ..thanks!

nice one!

int main() { int t; cin >> t; while(t--) { string w; cin >> w;

    if(next_permutation(w.begin(),w.end())==0)
    cout << "no answer " << endl;
    else
    cout << w << endl;
}
return 0;

}

I would suggest all to have a look at this article instead of looking for code in the disscussion. The approach in the article is readily comprehensible and decipherable.

This one is great.

really thanks for this man ... I really needed this next_permutation raw logic..

Very well explained by the person in the link above.

Thanks for sharing!!

cool. thanks man. I've been doing this exercise for two days..

this is a very good explanation!

here is my solution in JAVASCRIPT :

HackerRank Bigger is Greater problem solution

*Hi , I have done the problem through the following code. Can anyone explain me where I commited the mistake *

I appreciate your help

thanks in advance

  	fun biggerIsGreater(w: String): String {
    for (i in w.length-1 downTo 1){
        for( j in i-1 downTo 0){
            if(w[i]>w[j]){
                val result = w.toCharArray()
                val temp = result[i]
                result[i]=result[j]
                result[j]=temp
                return  String(result).substring(0,j+1) + String(result).substring(j+1,w.length).reversed()
            }
        }
    }    
    return "no answer"

}

Thanks a lot!

Is there mistake in code?? We should do : arr[j] >= arr[i-1] for j>=i but in code they did : arr[j] <= arr[j-1]? why ? is this incorrect or am I missing something?

thank you so much i was missing the last sorted suffix part

Brilliant. Thanks!