I'm doing a task on code wars and it doesn't work

I did a task on code wars 4 kuy (Next bigger number with the same digits) and it seems to me that the problem is not even in my code, but on the site. When you click on the test, the program works correctly, but when you click on attempt, it doesn't.

Here are the instructions:

Create a function that takes a positive integer and returns the next bigger number that can be formed by rearranging its digits. For example:
12 ==> 21
513 ==> 531
2017 ==> 2071
nextBigger(num: 12)   // returns 21
nextBigger(num: 513)  // returns 531
nextBigger(num: 2017) // returns 2071
9 ==> -1
111 ==> -1
531 ==> -1

Here is my code:

public static long nextBiggerNumber(long n) {
int count = 1;
char tmp;
char[] array = Long.toString(n).toCharArray();
for (int i = 0; i < Long.toString(n).length() - 1; i++) {
if (array[array.length - (count + 1)] < array[array.length - count]) {
tmp = array[array.length - count];
array[array.length - count] = array[array.length - (count + 1)];
array[array.length - (count + 1)] = tmp;
break;
}
count++;
tmp = 0;
}
if (Long.parseLong(String.valueOf(array)) == n) return -1;
/********************************************************************************************************************************/
char[] second = new char[count];
String.valueOf(array).getChars(array.length - count , array.length, second, 0);
int N = 1;
for (int i = 0; i < second.length - 1; i++) {
for (int j = N; j < second.length; j++) {
if (second[i] > second[j]){
tmp = second[i];
second[i] = second[j];
second[j] = tmp;
}
}
N++;
}
String mainString = String.valueOf(array).substring(0,array.length - count) + String.valueOf(second);
long mainLong = Long.parseLong(mainString);
System.out.println(mainLong);
return mainLong;
}

Here is error:

Test Results:
KataTests
basicTests
randomTests
Log
335686145
expected:<335685146> but was:<335686145>
Stack Trace
Completed in 6ms
biggerTests
Log
123456798
1234567908
59884848493558
expected:<59884848483559> but was:<59884848493558>
Stack Trace
Completed in 1ms
Completed in 30ms

Perhaps I don’t understand something, but it seems that the program on the site itself is not working correctly, because in randomTests and biggerTests a number is displayed that is not more than the first, but less.

The Problem

The next number of say abcdef would be something like abcefd, having a fixed prefix.

One should note that 1357 is the lowest value (increasing) and 7531 is the highest value (decreasing).

Look at

467468
467486   decreasing order 86 = largest, replace 4 with next higher 6 and inc 48
467648
467684
467846
467864
...

So the algorithm is (reminiscent of school addition with carry):

• Take the digits at the end that are decreasing (highest), say 85441 in [...][2]85441.
• The next higher digit after 2 is 4
• Create the next number ...[4][12458] with increasing digits (lowest).

The code

I will not spoil your coding efforts by a solution, but in general:

Iteration has to start at the highest index decreasing.

public static long nextBiggerNumber(long num) {
char[] digits = Long.toString(num).toCharArray();
int n = digits.length;
int i = n - 1;
--i;
while (i >= 0 && digits[i] >= digits[i + 1]) {
--i;
}
if (i < 0) {
return -1L; // No higher number.
}
// Now digits[i] must be replaced with next higher digit [>i].
// Mind that digits[i+1]..[n-1] are decreasing.
// And then at [i+1]..[n-1] everything must be increasing.
...
return Long.valueOf(new String(digits));
}

One must take care of repeating digits (>=, next higher digit).

Full solution, on request:

public static long nextBiggerNumber(long num) {
char[] digits = Long.toString(num).toCharArray();
int n = digits.length;
int i = n - 1;
--i;
while (i >= 0 && digits[i] >= digits[i + 1]) {
--i;
}
if (i < 0) {
return -1L; // No higher number.
}
// Now digits[i] must be replaced with next higher digit [>i].
// Mind that digits[i+1]..[n-1] are decreasing.
// And then at [i+1]..[n-1] everything must be increasing.
// Swap middle digit with a higher one.
char middle = digits[i];
for (int j = n - 1; j > i; --j) { // start with smalles in decreasing right subarray.
if (digits[j] > middle) {
digits[i] = digits[j];
digits[j] = middle;
// Right subarray still is decreasing.
break;
}
}
// Reverse right to lowest value (increasing subarray).
for (int k = i + 1, j = n - 1; k < j; ++k, --j) {
char digit = digits[k];
digits[k] = digits[j];
digits[j] = digit;
}
return Long.valueOf(new String(digits));
}

To test this a unit test would be ideal (could check that the next bigger number is indeed bigger), here a main.

public static void main(String[] args) {
long[] nums = {24354L, 3832L };
for (long num : nums) {
System.out.printf("* %d%n", num);
long numi = num;
do {
numi = nextBiggerNumber(numi);
if (numi == -1L) {
break;
}
System.out.printf("  --> %d%n", numi);
} while (numi != -1L);
}
}

Compiles; tested the results just perfunctory.

Such problems one should sufficiently "visualize" - play computer on paper.

ASCII Art

                  ___
Number           |   |___
|   |   |___ ___
___|...|...|...|...|.......
| a |   |   |   | b |___
|   |   |   |   |   |   |___
...          |   |   |   |   |   |   |   |
_____________|___|___|___|___|___|___|___|
^               ^ 
'------swap-----'
___
|   |___
___|   |   |___ 
|...|...|...|...|___........
| b |   |   |   | a |___
|   |   |   |   |   |   |___
...          |   |   |   |   |   |   |   |
_____________|___|___|___|___|___|___|___|
[                   ] 
'------reverse------'				   
___
Next Number                       ___|   |
___             ___|   |   |
|   |....... ___|...|...|...|
| b |    ___| a |   |   |   |
|   |___|   |   |   |   |   |
...          |   |   |   |   |   |   |   |
_____________|___|___|___|___|___|___|___|

1. After a the array is decreasing there is no higher combination in that subarray.
2. So the next higher combination involves all from and including a.
3. Taking b > a and the rest increasing will give the next number.