CareerCup

This is a "next permutation" problem and the algorithm for solving it is as follows:

0. Let us assume that digits are numbered 0..(L-1) starting from the lowest digits.
1. Find the first (starting from the lowest) digit d[i] such as:
d[i] < d[i-1], 0 < i < L
2. Find the first (starting from the lowest) digit d[j], which is greater than d[i]:
d[j] > d[i], 0 <= j < i
3. Swap(d[i], d[j])
4. Reverse digits from 0 to (i-1)

The complexity of this algo is O(L)

function nextBiggest(val){
   var a = val.toString();
   for(var i = a.length - 1; i >= 0; i--){
      var b = parseInt(a.charAt(i));
      if(b == 0){
         continue;
      }
      for(var z = i - 1; z >= 0; z--){
         var l = parseInt(a.charAt(z));
         if(l < b){
             a = a.replaceAt(i, l.toString());
             a = a.replaceAt(z, b.toString());
             return a;
         }
      }
   }
   return a;
}

Take the last digit.
Find the first digit on the left that's smaller.
Swap
All digits to the right of the swapped digits to be sorted in ascending order

Correct algorithm: We swap the rightmost digit, which has larger digits to its right, with the next highest digit value. (for example, in 15864, the rightmost digit which has larger digits to its right is 5, and the next highest digit is 6, so we get 16854).
Then simply sort the digits to its right in ascending order (in this case, the last 3 digits, so we get 16458).

Complexity O(N log N), space used O(1) if sorting done in-place.

Code in python:

def next_perm(l):
  k=len(l)-1
  pos=None
  while k>0:
    k-=1
    if l[k]<l[k+1]:
      pos=k
      break

  if pos:
    k=len(l)-1
    while k>0:
      if l[k]>l[pos]:
        break
      k-=1

    l[pos], l[k] = l[k], l[pos]
    l[pos+1:]=sorted(l[pos+1:])

def main():
  l=[2,1,8,7,6,5]
  print l
  next_perm(l)
  print l

if __name__ == "__main__":
  main()

Traverse the given number from rightmost digit, keep traversing till you find a digit which is smaller than the previously traversed digit.
Swap the digits.
Sort the digits right to the swapped index.


String findNextNumber(char[] n)
{
String next = null;
char lastDigit = n[n.length -1];
int i = n.length -2;
for( ; i >= 0 ; i -- )
{
if(n[i] < lastDigit){
{
swap(n, i, n.length -1);
sortArray(n, i+1);
next = String.valueOf(n);
break;
}
}
}
return next;

}

Take the last digit.
Find the first digit on the left that's smaller.
Swap
All digits to the right of the swapped digits to be sorted in ascending order

Make a queue to store digits
Iterate through the digits in the number starting at the rightmost position (least significant)
add the digit to the queue
if there is a digit to the left
if the digit to the left is smaller than the head of the queue
put the left digit in a temp
replace the left position with the head of the queue
put the temp in the current digit position
and output the remaining integers from the queue
return the new number
else return -1

Complexity is O(n) where n is the number of digits and Memory is O(n). It could be made memory O(1) if the processing was done in more of a String char approach, but I thought moving to arrays and string / char conversions would be slower.

public static int nextLarger(int val){
	if(val < 12){
		return -1;
	}

	Queue<Integer> queue = new LinkedList<Integer>();
	queue.add(val%10);
	val /= 10;
	while(val > 0){
		int nextVal = val %10;
		val /= 10;
		if(nextVal < queue.peek()){
			val = val * 10 + queue.remove();
			val = val * 10 + nextVal;
			while(queue.peek() != null){
				val = val * 10 + queue.remove();
			}
			return val;
		}
		queue.add(nextVal);
	}
	return -1;
}

Algorithm
I) Traverse the given number from rightmost digit, keep traversing till you find a digit which is smaller than the previously traversed digit. For example, if the input number is “534976”, we stop at 4 because 4 is smaller than next digit 9. If we do not find such a digit, then output is “Not Possible”.

II) Now search the right side of above found digit ‘d’ for the smallest digit greater than ‘d’. For “534976″, the right side of 4 contains “976”. The smallest digit greater than 4 is 6.

III) Swap the above found two digits, we get 536974 in above example.

IV) Now sort all digits from position next to ‘d’ to the end of number. The number that we get after sorting is the output. For above example, we sort digits in bold 536974. We get “536479” which is the next greater number for input 534976.

def find_next(a):
	a = [int(i) for i in str(a)]
	i = len(a) - 1
	while a[i-1] > a[i]:
		i -= 1
	j = len(a) - 1
	while a[j] <= a[i-1]:
		j -= 1
	a[i-1],a[j] = a[j],a[i-1]
	a = a[:i] + a[:i-1:-1]
	a = [str(i) for i in a]
	a = ''.join(a)
	return int(a)

int function(int number) {
                StringBuilder str = new StringBuilder(String.valueOf(number));

                for (int i = str.length() - 1; i > 0; i--) {
                        if (Integer.valueOf(str.charAt(i) - '0') > Integer.valueOf(str.charAt(i - 1) - '0')) {
                                int index = str.length() - 1;
                                while (index > (i - 1)) {
                                        if (Integer.valueOf(str.charAt(index) - '0') > Integer.valueOf(str
                                                        .charAt(i - 1) - '0')) {
                                                break;
                                        }
                                        index--;
                                }

                                char temp = str.charAt(i - 1);
                                str.replace(i - 1, i, String.valueOf(str.charAt(index)));
                                str.replace(index, index + 1, String.valueOf(temp));

                                int j = str.length() - 1;
                                while (j > i) {
                                        temp = str.charAt(j);
                                        str.replace(j, j + 1, String.valueOf(str.charAt(i)));
                                        str.replace(i, i + 1, String.valueOf(temp));
                                        i++;
                                        j--;
                                }

                                break;
                        }
                }

                return Integer.valueOf(str.toString());
        }