4 kyu
Next bigger number with the same digits
11,392 of 38,923GiacomoSorbi
Loading description...
Strings
Refactoring
This comment has been reported as {{ abuseKindText }}.
Show
This comment has been hidden. You can view it now .
This comment can not be viewed.
- |
- Reply
- Edit
- View Solution
- Expand 1 Reply Expand {{ comments?.length }} replies
- Collapse
- Spoiler
- Remove
- Remove comment & replies
- Report
{{ fetchSolutionsError }}
-
-
Your rendered github-flavored markdown will appear here.
-
Label this discussion...
-
No Label
Keep the comment unlabeled if none of the below applies.
-
Issue
Use the issue label when reporting problems with the kata.
Be sure to explain the problem clearly and include the steps to reproduce. -
Suggestion
Use the suggestion label if you have feedback on how this kata can be improved.
-
Question
Use the question label if you have questions and/or need help solving the kata.
Don't forget to mention the language you're using, and mark as having spoiler if you include your solution.
-
No Label
- Cancel
Commenting is not allowed on this discussion
You cannot view this solution
There is no solution to show
Please sign in or sign up to leave a comment.
I decided through string slices and sorting, the complexity of the algorithm is O(n), the task itself is not difficult, you just need to understand what they want from you and how to implement it, it was very interesting, thank you!
515 should equal 531 2020 should equal 2071 -1 should equal 441 -1 should equal 414
how is this? how can I get 531 from 515 as next bigger? author are u sure tests are ok?
You read the error message incorrectly. 515 is not the input number, it is your answer.
.
I got the same... actually, how does 2017 return 2071? Shouldn't it be 7210? The test seems erroneous.
I think tests are broken on golang, I pass all the random tests, but I fail 2 predetermined ones:
And
I am maybe stupid, but that does not seem to be right answers at all, how is the 0 bigger than 8 and then in the second one 9 has to jump to the end?
That's exactly why your answer isn't correct. There are smaller numbers that are bigger than initial number. 1234567890 < 1234567908 < 1234567980.
Maybe you misunderstood the task, but the clue is in the title.
Oh, yeah, I thought 1 digit could only move 1 place, makes sense, my mind went completly blank. Thank you
I thougthI understood the question , but the test don't seem to be clear , If we are supposed to rearange all the number and compare if the input is greater than all the possible permitation, please explain me this 12 ==> 21 = > Ok 513 ==> 531 => OK 2017 ==> 2071 => shouldn't 7210 ??
No, it's not about finding the largest permutation. It's about finding the next one which is larger than the current.
I got the same... actually, how does 2017 return 2071? Shouldn't it be 7210? The test seems erroneous.
No... 7210 is the largest value you can make with the same digits as 2017, but the task is not to find the largest value with the same digits. The task is to find the next larger value with the same digits, which is 2071. The test is not erroneous, but I'm not sure how it can be explained any further.
You can gesture with your hands when explaining, I think it will be clearer this way👐
tht s the third problem of this kind i found in a row! I tried to use brute force on all of 'em but it wasnt working, so i did some research and i realized these problems are more like riddle coz u gotta find a trick to solve them, they are everything but intuitive
i get this error: java.lang.NumberFormatException: For input string: "9876543210" I guess its because the input value is bigger than the max size of a long value. Is this my mistake or a mistake of the tests? (I use java 17)
when you are not sure, please do not raise an
issuejust yet. try your code on your own machine first, and see what happens. you can ask aquestionfor help. there are more than 3,000 Java solutions so it is unlikely that the tests are faulty.This comment has been hidden.
You're misunderstanding the assignment.
Testing for 4977764433221000 (No brute force solutions 🙃)
God damn it :D
this is not a kyu4
yes it is! Dude this is problem based on a trick , u just have to get it and u ll easily solved it
This comment has been hidden.
411 isn't the input, it's what you returned. You can print function arguments to console https://docs.codewars.com/training/troubleshooting/#print-input
This comment has been hidden.
But not the next biggest number to 2071
7210 should equal 2071 why? 7210 is bigger than 2071. so why 7210 is incorrect?
Because 7210 is the greatest, not the next bigger number, the first number in the error message is what your function returned instead of the correct value. If you want to see the input, print it. It's been discussed before many times, like here: https://www.codewars.com/kata/55983863da40caa2c900004e/discuss#6500a4bf67abf10ae9d76133
This comment has been hidden.
I think I have a recursive solution to this, but on very large numbers it times out. Is this kata meant to force a non-recursive solution? Or is there an error with my solution?
The problem is not recursion, if you generated all permutations non-recursively, your solution would still timeout. You need a more efficient solution. See https://docs.codewars.com/training/troubleshooting#timeout.
Can someone clarify why for "Testing for 21529574" expected 21529547? 21529547 isn't the next bigger number. This is the previous number to 21529574. The next bigger number is 21529745. -- Thanks.
Please read the entire message:
This message indicates that your function incorrectly returned
21529547when the correct output was21529745.This comment has been hidden.
numbers_list[i] == n) unless the number is 1 digit, which has been handled by the earlier if statementI didn't mention all, but these are the red flags that can easily be spotted right away in your code.
Finally! Took me a whole day, man. Nice question. When I thought I'm very close, I later felt it's too far but it suddenly hit and I was actually very close all the time. that feeling!
This comment has been hidden.
You need to find a solution that involves swapping digits around. I cannot read your code because I do not know enough, but I tried both methods of:
both methods were too slow, and would time out.
the key is logically swapping digits around.
This comment has been hidden.
Approved
This comment has been hidden.
not a kata suggestion
Good problem!
I'm receiving an error that says "Test crashed.Caught unexpected signal: SIGSEGV (11). Invalid memory access". Is my code wrong or is there something wrong with the test case? if my code is wrong, how can i fix it?
Your code is wrong, but we do not know how you can fix it.
Can you help me if I post my code (with the spoiler tag)?
Yes, I think we would be able to help you if you post your code, with a spoiler flag, and properly formatted.
You can also come to Codewars Discord and ask in
#help-solve, or#c.you might be able to pinpoint where it crashes with the help of prints. make sure to flush after each print so that the text makes it out before the segfault happens.
you might also be able to run various diagnostic tools locally like valgrind asan or a debugger
you could also stare at your use of pointers some.
This comment has been hidden.
This comment has been hidden.
Does anybody else have some of their results coming up as NoneTypes? Can't figure out why
Read the last part of the description again, your code is failing with single digit numbers.
Tests is wrong My code work perfect
That's what I tell my boss every time tests fail in my project.
C++: in random test cases values are larger than long, should input and return long long type
on 64-bit Linux (on which Codewars runs),
sizeof(long) == sizeof(long long) == 8. could you share examples of values "larger than long" ?my bad, thought long type is 4 bytes when long long type is 8
it is the case on 32-bit Linux and on 32-bit and 64-bit Windows ;-)
see here
This comment has been hidden.
This comment has been hidden.
Tests hardened, your solution now fails.
Interesting task, in python I implemented generator that generates next element of permutation for those numbers. Seems to work fine but test cases are timing out after 3/4 test cases for bigger numbers. Any hints for optimazation?
Well, generating permutations is not the correct way to go about this task. If the number contains a lot of digits, you will end up generating a huge amount of different permutations, which is what leads to your timeout. Look for a pattern between the input that you're given and the correct return value. There is a method to figuring out the next highest number. Try this kata if you're stuck: Basics 08: Find next higher number with same Bits (1's). It's a very similar premise, but it's made simpler by the fact that you're only dealing with 1's and 0's. If you can spot the pattern there, you may be able to apply that knowledge to this kata.
How can 2017 return 2071? Since 7210 is the largest number with its digits?
The task is to return next bigger number with the same digits, not the biggest number with the same digits.
thanks,
He asks to give the "next" bigger integer, according to this example, after 2017 (using the same numbers we have) the next bigger integer is 2071 which we get by changing the last 2.
Lmao nice cheat on C++. Why it is not at least 5kuy for C++?
One kata cannot have different ranks for different languages. Kata rank is the same for all languages.
Kotlin: moved to v1.5, improved assertion message
This comment has been hidden.
Please use appropriate formatting when posting code. See https://docs.codewars.com/training/troubleshooting/#post-discourse.
Your solution is too slow. Not a kata issue.
Something wrong with the test itself: expected:<1234567908> but was:<1234567980>
If the expected is: 1234567980 the original should be
1234567098 -> 1234567890
1234567980 -> 1234569780
1234567908 -> 1234567980
1234567890 -> 1234567980
None of these results with 1234567908
Meanwhile message: expected:<1234567908> but was:<1234567980>
Expected is
1234567908, and1234567980is what your solution returned.To see the input, just print it. There is no need to guess what it was and it'll be easier to debug your code.
I've tried but compiler escapes values printouts, at lest in kotlin
No, you are right, it happens only when you try to add velue printout to exception
why function must return 2071 if the argument is 2017 (2017 ==> 2071) but function could return 2107 (2017 ==> 2107) or not?
No,
2017 < 2071 < 2107.Please don't raise a kata issue when you're simply asking a question. See https://docs.codewars.com/training/troubleshooting/#post-discourse
Not a kata issue.
because 2071 comes before 2107. They're asking for the next bigger number
I have the same issue when using the Attempt button: times out at 12 seconds with the suggestion to refactor. Although I pass the Test button in 60 ms. And 12 ms on my computer, even when using numbers approaching Int64.MaxValue. Please see here for test results: https://i.imgur.com/4fsqtvg.png.
Is it possible to see what the full test is doing?
Please test
1999999999999(expected9199999999999)I solved it now in C# and can see your solution. Checking permutations is just too slow. You need a faster approach. Not a kata issue.
Oh wow, thank you. Sorry for doubting the timeout suggestion, I think I was out of ideas and was hoping this was a bug. Okay, back to the drawing board.
There are issues with the test cases on the python end
Please be specific.
No, there aren't:
And OP passed the kata so...
I think something it's wrong with C# performance. It doesn't seem right that in my environment my tests runs in less than 180ms each, 370ms all seven of them (including the big numbers ones), and that in here I get a 12000ms timeout. I mean; I'm using a laptop from 2012...
There's nothing wrong with the C# tests. Apparently, permutations is not really efficient, especially with big numbers. So, try to find another algorithm for this problem.
Not a kata issue.
This comment has been hidden.
This comment has been hidden.
The one in the expected message is your result, not the input. You failed at input
9876543210, which is already the biggest number that can be made.Not a kata issue.
Omg i feel so stupid :D sorry
This comment has been hidden.
No, it's next bigger, not biggest. Please read the description carefully.
Not a kata issue.
Separately simple tests pass completely, but if you try to pass full tests, they fall with the wrong answer. If you run the program via clang++ on my computer, then the same tests pass and output what they ask for.
wtf with tests on c++
Your solution has a bug, it reads a vector out of its bounds. Replace all calls to
vec[i]withvec.at(i)and you will see how it crashes.Your solution has a bug, it's not a kata issue.
I get timed out on bigger numbers. Is it possible that my code is too slow?
Yep I checked on tests and it throws timed out if number exceeds 100m. FYI, creating an array of all possible combinations is not a good solution.
Just when I felt I knew something I discovered I barely know anything lol, even with Google I couldn't get past 12000 ms "testing". It works now but the code is completely trash and copied from some permutation tutorial :/
I have a question. In sample tests in Rust, the error message, says "Your result (left) didn't match the expected result (right)", and in those test is the other way: the expected result is left. I might have seen it bad or in the random tests is arranged differently, but I'm kinda confused now
Fixed. Thanks for bringing this to my attention.
There's something wrong with these tests)
From the number 2071 the maximum can be obtained 7210. From the number 144 the maximum can be obtained 441. BUT in tests i saw this: 2017 ==> 2071 and 144 ==> 414
lmao
read the title of the kata
i'm sorry
Wow that was tough, 4 months into development and that one caned my ass. Took me a good 6 hours to pass all tests. Im such a bloody noob :D
Right? Parsing back to front and then back to the back just hurts my brain. Fun though, would solve again.
This comment has been hidden.
Sorry but your code not working is not a kata issue. Closing.
Using global vars is a source of problems when calling your function multiple times like it's done in the tests. I'm not saying that's the only problem in your code tho.
Most test cases require a single swap between ONLY two digits to find the answer e.g. 123456 --> 123465
I would suggest adding at least one base test case for this requirement e.g. 152 --> 215 (as opposed to 251, which would be the answer for an algorithm with a single digit swap)
a good one
There is an issue with C++ tests:
n = 9876543210 Expected: equal to -1 Actual: 9876543210
Clearly it shouldn't be -1Okay i'm stupid, should have read the instructions
Did you read the description?
How is
9876543210bigger than9876543210?I don't understand. I write on JS. 95 tests passed, but 57 had similar errors. Example: Testing for 1861 => expected 8161 to equal 6118 Testing for 685 => expected 865 to equal 856
6118 is definitely closer to 1861 than expected 8161 etc.
But it does not say that 8161 is an expected answer, does it?
The first value in that error message is your wrong answer. Not a kata issue.
The test results are incorrect
This bug report is bad.
The tests are fine, your code is wrong, why would you need to hardcode the test with
144as input otherwise?You can clearly see that the next bigger number with the digits of 144 is indeed 414, not 441 as your code (without the hardcoding part) returns.
When you think there is a problem with the tests, first check how many completions in the language you're using the kata already has:
Then provide some proof about what you think is wrong: language, input, expected output, your output, optionally, your code.
Attempting the challenge on python, I am receiving this response for lengthier numbers. Response: "Incorrect answer for n=123456789: 123456789 should equal 123456798"
And what exactly is the issue? For
n = 123456789the next bigger number is123456798as indicated by the message.Would the next bigger number not be 213456789?
No,
123456789 < 123456798 < 213456789.next bigger. ;)
Haha, I now understand. Thank you. How to remove the issue?
Why am i getting error expected 52398665 to equal 52398566? That doesn't make sense, because 52398566 < 52398665 and we are looking for next bigger, not smaller. Meanwhile my code returns 52938665 which seems like right answer.
Without the input value we can't know if your're right or wrong, probably wrong tho:
Take a look at some failed test:
You can see that your function returned 80532 and the next bigger number with the digits of 80352 is 80523.
This comment has been hidden.
Why does 10990 turn into 19009 but not into 19090? Why is 19009 bigger number than 19090. Why do we swap 9 and 0 if it is a less number (ones that at the end of the number)?
Because:
and you should return the next bigger number, not any bigger number.
in test case 21 why its -1? whats the issue here?
The only other number you can make with those digits is 12 and that's not bigger than 21.
If you meant the 21st test, those are random, print the input. But you should be able to see it even without printing it, because of how tests are made.
Cool kata :p
Shouldn't 2071 be 7210? Seems like the tests are wrong.
It depends what is the input. What is the input which expects answer of 2071 while you expect the valid answer to be 7210?
I misred the question. It's asking for the next biggest number and not biggest number that can be formed.
Next bigger.
finally i solved this kata!) Thanks
I don't get how this is possible, I'm using Heap's algorithm and I'm still getting time limit exceeded
Heap while a good idea, is going to take too long, there is a faster approach, that wouldn't require making all the permutations.
bro, it's not about the algorithm, take a closer look at the test numbers about -1, and you will understand what the point is)
not understand the logic... for an example in indexes: number 9209546890550 must have 9209546895005 - to get the correct answer we need to make 2 step ( 5 - 0 and 0 - 5), number 4465 must have 4546 - to get this we need also 2 steps number 29977643211 -> 39977642211, here only one step... but if have 2 steps as in previous 2 numbers we can get smaller int for an example 31•••• etc
Took alot of brainpower for this one, really tough but highly recommend.
My first ever 4kyu too :D
Well done bro, i'm struggling on that one xD !
well I foolishly wrote all the logic for mod oper to get each individual number w/o str conv for sub 10000 numbers due to the front pg test cases not having enormous numbers. Just to realize that it's going to take a permuatation algo. Seems tough for a 4kyu
The type long is not sufficient for the test with the number 59884848459853. I had to change it to long long in order to run tests on large numbers.
This comment has been hidden.
This comment has been hidden.
Not a kata issue, the next bigger number is indeed 1234567908 not 1234567980.
My solution works correctly in clion on laptop , but when I copied my solution and tried it , I got an error: Expected: 19009 Actual: 10990. When I putting 10990 in clion , my solution returns 19009. I actually tried to copy it about 3 times and all another cases is OK, so what type of problem I have and maybe somebody knows what to do? P.S.: I also got an error/warning for using atoi(). What is atoi() problem and why I should refuse to use it?
Print the input: https://docs.codewars.com/training/troubleshooting/#print-input In the error message, actual is what your function returned instead of the expected value. Without the input we can't tell if your code is right or wrong.
If you got a message that
"Expected: 19009 Actual: 10990."and then you put10990in your IDE, then you read the tests an failure messages wrong. "expected" is what tests want you to return, "actual" is what you returned, andn = XXXXXXdisplayed in an assertion message is what you should put in your IDE.The only way to return 0 from your solution is when it catches and silences an exception. Generally, your code seems to throw exceptions left and right, and then forcibly silences them.
There is quite a lot of fixing to do. Removing all
try / catch(...)would be a good first step.Not a kata issue.
The solution is passing all test cases, but the test results show error for in-efficient algorithm
This comment has been hidden.
Congratulations on solving, but please don't post "spoilers" in Discourse - although admittedly you are not specifically giving a coding solution, it is giving a big hint to finding a correct approach to solving.
There are already lots of partial hints and detailed troubleshooting advice in the various replies below, if people are stuck they can make the small effort to read through such replies which cover 99% of the usual mistakes.
Especially on 4 kyu + katas, where users are supposed to have to use their own brains a bit to solve them.
"Testing for 3998733210 (No brute force solutions 🙃)" what? why? theres no problem when i tryin it on other platform :')
Because your solution is too slow. How long does it run on other platforms for
n=3998733210?Your solution being too slow is not a kata issue.
"Testing for 29977643211 (No brute force solutions 🙃)" - get this issue with different solutions
This test is to prevent inefficient/slow solutions and force you to use an efficient algorithm. If you use the right algorithm you have a lot of headroom to pass the tests in all languages even if your implementation isn't good.
This comment has been hidden.
Because 2071 is the next number bigger than 2017 with the same digits, and 7210 is not the next number after 2017 with the same digits.
This comment has been hidden.
This comment has been hidden.
Please add number 19 000 000 to the big numbers test. Next number is 90 000 001 (the difference is more than 70 000 000). That will be a good test for the code performance.
This kata already has some difficult random tests to check for performance. Do you mean they are not sufficient?
Oh indeed, it seems there is no performance test for Java. Good catch!
This comment has been hidden.
Reraised as an issue.
The author of the kata, sorry, you accidentally did not have a typo in the description, the returned value is:
nextBigger(num: 2017) // returns 2071
After all, the maximum integer value from a given integer value is 2017, rearranging its digits, we can get 7210.
nextBigger(num: 2017) // returns 7210
But the kata does not ask for the maximum integer value from a given integer value?
It is the next bigger, not the biggest.
Indeed, it is.
This comment has been hidden.
Please scroll up this page and find "Test Cases" section (next to "Description"). If you expand it you will see the list of all "attempts".
Scala translation
This comment has been hidden.
goofy suggestion
This comment has been hidden.
But you do not show anywhere what the initial value is?
Initial values:
59884848495583;6030;640010;917.This is in the sense that the answer to the test already contradicts the task. The answer is less than the original number.
Obviously, you're misreading the logs, the first value in the error message is what your function wrongly returned, not the input value. To see what it was, print it. Not a kata issue:
Of the values that you are showing, only the value
5988...is a fixed test that we can reproduce easily.However, already you are reading it wrong - you claim the initial value is: 59884848495583
but the test is actually using input: 59884848459853
I have bolded the digits you are getting wrong.
Make sure you are reading tests correctly - also in your code, add a
print(name_of_input)somewhere if you want to double check.You most probably read logs incorrectly, and you mistake actual values returned by your solution, with input values.
I changed the way how tests are organized to give better feedback on failure, hopefully this will make it easier for you to spot your mistake.
Then it turns out that:
"It should work for random inputs too: 6030 should equal 6003"The initial value is:
"6003"?The answer is:
"6030"?Then my code works correctly and everything corresponds to the correct answers, but the kata does not pass.
Double reply so you see the updated message: it seems, indeed, that this is due to you reading the error message incorrectly.
You posted in your original message:
"59884848495583 should equal 59884848483559"and then you said that59884848495583is the initial value: NO this is your mistake - you are not reading error message correctly.In the statement
x should equal y-xis what your code is currently returning andyis the actual correct answer.As stated earlier - you should add the following to your code:
print(n)- now you will see what the actual input values you are being passed are.Just to be 100% clear:
No, you got this part wrong.
The input is not in the error message, as I said before.
Yes, my fault, sorry. I really misunderstood the test.
There are no problems with kata, thanks for the explanation.
IN KOTLIN error occurs when converting char to int using "Char.digitToInt()"
Error src/main/kotlin/solution.kt:5:29: error: unresolved reference: digitToInt val list = num.map { it.digitToInt() }.toMutableList() ^
as you can see here this requires at least Kotlin
1.5, but this Kata is only available in Kotlin1.3Wow, this is one of those where just when you feel you solved it you find out you were not even close, mostly due to a misunderstanding of the mechanics that yield the next bigger number. Check inputs against expected output carefully! and add your own tests with large numbers. Great kata to challenge yourself with!
It should work for random inputs too: 7745 should equal 7547 , but next bigger number should be 7754. 7547 < 7745
Your function returns 7745 instead of 7547, print the input. It could be 7475.
Hi! Why do argument and returned types in C++ solution have type of long: long nextBigger(long n)? Whereas in tests I got enormous values of argument, such as 6922181194580306956, and max value of long is 2147483647 of course.
If you receive a long, and max value for long is of course 2147483647, then how would it be possible that you receive 6922181194580306956 as input?
Hint:
cout << sizeof(long);.in my system cout << sizeof(long); gives 4 (Bytes), on the site it gives 8 (Bytes). Well, I have to use long long in my system, then change the type for the site
This comment has been hidden.
JavaScript currently has 8115 completions, the tests are valid and it's your code that is wrong. By the way, the reference solution correctly returns
713for the input371.See https://docs.codewars.com/training/troubleshooting.
What does your solution return for
n=9876543210?sir my solution has outputed 713 while the site gave my error saying it should be 731 for 371, Test.assertEquals(nextBigger(371),731) this line is written as one of the demonstrating examples below, if you take a look at me solution you will see it compares every number ascendingly with the tested number, while this is certainly terible performance it always give the right ans.
There is no such test in javascript, backup your code, click reset, paste it and try again.
You should see these tests:
thanks it now works fine.
Can you help me to figure out what does this error means?
UndefinedBehaviorSanitizer:DEADLYSIGNAL ==1==ERROR: UndefinedBehaviorSanitizer: SEGV on unknown address 0x000000000000 (pc 0x00000042c030 bp 0x7ffd4839c200 sp 0x7ffd4839c1c0 T1) ==1==The signal is caused by a READ memory access. ==1==Hint: address points to the zero page. ==1==WARNING: invalid path to external symbolizer! ==1==WARNING: Failed to use and restart external symbolizer! #0 0x42c02f (/workspace/test+0x42c02f) #1 0x42581f (/workspace/test+0x42581f) #2 0x429268 (/workspace/test+0x429268) #3 0x4285a2 (/workspace/test+0x4285a2) #4 0x426dbe (/workspace/test+0x426dbe) #5 0x42662d (/workspace/test+0x42662d) #6 0x42631b (/workspace/test+0x42631b) #7 0x42bcd5 (/workspace/test+0x42bcd5) #8 0x42595d (/workspace/test+0x42595d) #9 0x7f4c5f37cbf6 (/lib/x86_64-linux-gnu/libc.so.6+0x21bf6) #10 0x404799 (/workspace/test+0x404799)
UndefinedBehaviorSanitizer can not provide additional info. ==1==ABORTING
This error means that you attempt to read out of bounds of a vector, or a string.
It's a bug in your solution, and not a kata issue.
This comment has been hidden.
This comment has been hidden.
What language?
What are the inputs of test cases your code fails?
Your solution seems to return invalid, too small values:
This does not seem to be the case. After adding logs to your solution, I can see:
Your code does not produce
1234567098.I am going to close this issue as a user error. If you are really, really sure your code is correct, plese post here:
You can also come to
#help-solvechannel of Codewars Discord, someone will definitely help there.2017 can be 7210.. 2071 is not the biggest or Expected 123456798 but got 987654321 how woud a number starting with 1 be smaller, when it contains 9 ?!
The kata does not ask about the biggest.
the kata ask a biger numer whit exacly same digits, and 2017 is the input and for output expect:2071 but 7012 is biger than 2017 and have the same digit but you got error
The kata asks (and in fact it is even stated in the title) for the next bigger number with the same digits.
It does not ask for "a biger numer whit exacly same digits".
With input digits
2017:the biggest number with same digits is
72107012is also bigger than2017, and has exactly same digits, but it is not the next bigger.Finally the next bigger number "after"
2017is2071. This is what the kata wants you to find.This comment has been hidden.
Spend some time yourself, because everything is correct, apart from your code.
This comment has been hidden.
This comment has been hidden.
B1ts, thanks you, I saw an error) I was wrong)
Can someone show me how to shuffle number but not use list?
Weird kata, don't recommend (
Recommendation is not a kata issue.
If you found a bug with the kata, please describe it in a new issue, with some more details.
This comment has been hidden.
Because
1234567980(your solution) is not the next bigger number after1234567890(the input) ???You can write them down:
Bigger numbers: Time of your function -0.0001659393310546875 Time of your function -0.00020432472229003906
Execution Timed Out (12000 ms)
how it possible?
When i.m trying to solve this kata in C i got passes all simple tests and then in random test i got this asser: 1204002415130177602 should be 1204002415130177206 Is is correct? I think that next bigger from "1204002415130177602" should be "1204002415130710267"
You read the message wrong.
What is the input of the test you failed?
Fixed tests to give better error messages.
This was difficult.
Hi everybody! Do any body knows Why result of 2017 is not 7210? It is mistake in example ?
The task is next bigger, not biggest. The next bigger number after 2017 would be 2071.
thks
This comment has been hidden.
Do you know what was the input of this test case?
Ahh sorry... I was wrong, the message say's what was returned by my function...
I tried to improve assertion messages to avoid this type of confusion, please see if errors are clearer now.
Test for javascript are completely not correct.
Please elaborate, afaik the tests are fine.
This comment has been hidden.
did someone have troubles with number 1234567089? may be i wrong but the next bigger smaller number 1234567098, not 1234567908?
The input is 1234567890, not 1234567089
Any ideas why with the random tests my input is correct till last 3 digits which seemingly appear out of nowhere. For example:
expected: 111222333444555678 actual : 111222333444555342
All other tests are passing and this is C++.
Edit: Ints in vector where digits are stored are correct, but when converting back to long at about 10^15 the unit, tens and hundreds value of long start getting changed by multiplication
I can't complete the Kata because one of the tests are invalid for TypeScript.
The input is larger than the test's output. The next biggest should be
1234569780Neither of those is the input, the first value is what your function returned, to see the input value, print it to the console yourself. Not a kata issue.
In file included from main.cpp:7: ./tests.cpp:7:22: error: use of undeclared identifier 'next_bigger_number' Assert::That(next_bigger_number(12), Equals(21)); ^ ./tests.cpp:8:22: error: use of undeclared identifier 'next_bigger_number' Assert::That(next_bigger_number(513), Equals(531)); ^ ./tests.cpp:9:22: error: use of undeclared identifier 'next_bigger_number' Assert::That(next_bigger_number(2017), Equals(2071)); ^ ./tests.cpp:10:22: error: use of undeclared identifier 'next_bigger_number' Assert::That(next_bigger_number(414), Equals(441)); ^ ./tests.cpp:11:22: error: use of undeclared identifier 'next_bigger_number' Assert::That(next_bigger_number(144), Equals(414)); ^ ./tests.cpp:12:22: error: use of undeclared identifier 'next_bigger_number' Assert::That(next_bigger_number(10990), Equals(19009)); ^ 6 errors generated.
Duplicate issue (see the one below), closing.
Incorrect function name in C++ sample tests.
Fixed
Damn, sorry for that.
This comment has been hidden.
Don't use itertools, use your brain.
The tests cases for Kotlin are completely wrong.
This is not the proper way to raise an issue. You must prove there is an issue with clear logs, examples, etc. About 200 persons solved this kata in Kotlin and nobody reported anything so you're most probably wrong. Please read this and don't raise issues so lightly in the future: https://docs.codewars.com/training/troubleshooting/
This comment has been hidden.
Try solving another kata and see if you get those points, sometimes that works.
Nope, I tried a 7kyu and an 8kyu, even those points didn't add on for me, is it a problem with my internet?
could you have possibly asked to see the solution in the past and forgotten about it? I've done that once
@protto, I am pretty new to this place, this is my first time even trying a 4kyu kata, I couldn't have seen the solution, and also as I just said: the 8kyu points and the 7kyu points also didn't add on for me:(
D translation
Timed OutPassed: 7Failed: ?Exit Code: 1 it shows me that my code passed all the tests but failed is ? and its not shown
This is telling that your code times out, which means it is too slow to perform all the tests.
In order to output huge numbers I need to return a string otherwise php will truncate the integer.
The test cases don't allow me to return strings though. I get: Failed asserting '21' is equal to 21.
If I change to return integers I fail in the obvious way of not returning the full number.
The inputs never get so big that php truncates them. I'm not sure what you mean by this anyway, in php, if an int gets too large it converts to a float with scientific notation, and you might lose some precision in the process, but it doesn't truncate the number. In any case, the largest inputs in php are around
10**14, which is well under when conversion to float happens. Something else is wrong in your code.Hey thanks for the response. I realize I was logging inputs incorrectly which led me to believe the function was being passed absurdly large integers. Doh!
I liked this kata when i finally figured out the algorithm. It would be faster if there had more sophisticated examples, hinting the logic of such search.
I having an error Value Error: invalid literal for int() with base 10: ' ' Does this mean the string I want to transform in int has some apostrophes in it ? Or some spaces ? It doesn't look like it but I can't test the code to know the output so I'm not sure.
No, it means you're trying to convert an empty string to an int.
You can use this:
print("newd: '" + newd + "'", flush = True)to see the value ofnewd.I'm passing test cases but then getting execution time out while submitting. :/
This comment has been hidden.
This comment has been hidden.
The value on the left -
7210- is what your code is returning. The expected value is on the right -2071.Without seeing your solution, I'm guessing you are trying to return the largest possible value, which would indeed be
7210, when the kata is specifically asking you to return the next bigger number that can be formed, which from2017is in fact2071.Firstly my code can't do it within required 12 sec. Now all tests completed in 34ms! Yahhou!
oh wow how did you do it? i also have this inefficient code that can't run the tests in time
Maybe not in the subject, but I can't solve the problem: the keyboard shortcuts ctrl+c and ctrl+v do not work in codewars. More precisely, they work differently: ctrl + v to move the cursor to the end. How to fix it?
This comment has been hidden.
(next_bigger(2017),2071) must return 7210 // and a lot of anything test
It's the next bigger, not the biggest.
Thank you so much, you made me read the condition correctly
The problem many will have with this kata is figuring out how to rearrange the number to get the next bigger number. Once you figure that out, the solution should be straight forward.
Actually the straight forward part was figuring out the rearrange. I've gotten so many bugs from the actually swapping of numbers that I want to quit and it's all because I am working with a long which has many less methods than a standard int.
This comment has been hidden.
Please use a spoiler flag when you post code, so users who didn't solve the kata can't see it (I put the flag for you this time). Also, use markdown tags to format your code or it's unusable, see there: https://docs.codewars.com/training/troubleshooting/#post-discourse
Please consider adding
1.5forKotlin,1.3is right from 2018. A little bit old...My code seems to work with every number I input. However, it times out of the final tests. Any suggestions?
I beleive I see this type of comment in every kata discussion. Please read
DOCShttps://docs.codewars.com/training/troubleshootingI had a bruce force solution which failed the random tests so refracted and managed to pass them all, feeling happy about it. So my question, do you only have to pass the test cases to complete the kata?
If you pass the attemp tests, you solved the kata (you did solve it, see: https://www.codewars.com/users/JustTanwa/completed ). See there for details: https://docs.codewars.com/getting-started/solving-kata
Congratualtions to the author on quite a demanding kata. Two things would be worth adding in my opinion:
I love this kata. First I made it so that only basic tests came out, and then basic and random tests and finally all of them. I'm still weak in algorithms, but the time limitation gave this kata a kick.
This comment has been hidden.
Your solution takes ages for n=1234567890.
Your code being too slow is not a kata issue.
I am 100% certain, the kata has errors:
Here is proof:
Examples 1:
It should work for random inputs too: expected 823 to equal 328.
823's next biggest is 832. And if the kata means 328, then 382 is the next biggest. Both ways wrong.
Example 2:
It should work for random inputs too: expected 87050867 to equal 87050768
87050867's next biggest is 87050876. And if the kata means 87050768, then 87050786 as the next biggest. Both are wrong.
None of those is the input, see the logs:
The problem is in your code, not in the tests.
The Kata has been solved more than 22k times, but it starts to fail only on your attempts :D
This comment has been hidden.
This comment has been hidden.
I know about this. it is a very hard problem. Only one small assert and 6 months. :)
This comment has been hidden.
I feel like the test cases are incorrect. 2071 => 7210, not 2710, no? 144 => 441, not 414.
No, read the description again, it's the NEXT bigger number, not the biggest.
Giving better examples would be nice!
Better like what?
This comment has been hidden.
This comment has been hidden.
Optimize your code ~~, not an issue
This comment has been hidden.
This comment has been hidden.
It was the same for me when I first encountered this problem ages ago; glad to have reproduced the experience :)
Please, adapt the input up to
LLONG_MAX(at least C, C++ and NASM) in order for this Kata to conform with its High Rank!This comment has been hidden.
shouldn't 1193 return 1319?
@krankos Exactly! Thanks a lot! Though the random generator is really bad! This input was not the only... Probably i was not attentive enough? So i will reopen this issue if i find one...
i almost broke my head
My code keeps getting execution timed out how do i fix that ;-;
same thing happens with me
Please see the first bullet point of this paragraph: https://docs.codewars.com/training/troubleshooting#timeout
Same!
Hi! Please add this anti-buteforce test case: Assert.AreEqual(9111111111111111111, Kata.NextBiggerNumber(1911111111111111111));
Just tested, it causes execution timeout
Which language are you refering to? Some languages don't test numbers so big. Can you give an example of solution (with spoiler flag) that passes usually all random tests but fails on this one?
This comment has been hidden.
This comment has been hidden.
C:
srandshould be called only once.it seems to have been fixed ?
Yes, this issue is already fixed.
COBOL Translation please review carefully
Approved
This comment has been hidden.
I'd expect it to have an elegan solution. That doesn't seem to be the case in Go.
i don't know what happend when i try to attempt my code it's show error like this
I have check the number on next one and if there bigger than the front one then i swap numbers and look for next before digit i already swap.
Did i miss understand something if someone understand please give me advice.
*** PS.Javascript ***
That algorithm isn't right, you can easily see it in those tests.
6136 (the expected value) is less than 6361 (the value your function returned) and is greater than 3661 (the input value).
Ohh i see a number should bigger than input just a 1 step
A big thanks :)
This comment has been hidden.
Please use spoiler flag when you give clues to a solution, even if they seem bad. This is a 4 kyu kata, so some efficiency is required and brute force won´t pass, whatever the way you do it. I don't see how to help you without spoiling. You have to think and try out considering the number and the digits that form it.
Execution Timed Out
When I see an i64 in the sample code I know that whatever my first solution is, it is going to fail with an overflow somewhere and its back to the drawing board :-)
This comment has been hidden.
This comment has been hidden.
Shorter code does not mean more efficient code, at all.
I figured. Any pointers you can offer? I'm using Ruby.
I solved this kata a long time ago, in several languages but not in Ruby so I cannot be sure, but try to avoid brute force and find a trick working directly from the number's digits.
After trying it out I can confirm: brute force does not pass in Ruby (but it does in some other language...).
"Rearranging its digits" - is it about side-by-side digits only (like in all given examples)? Or is it about every digits in the number? I.e. is "2107" correct output for "2071" incoming, or "2701" only goes right?
Yes. It is the next bigger number.
Thank you!
This comment has been hidden.
vrode ya reshil, no esli dobavlu proverky v konce to po vremeni ne uspevaet. Vnatyre hyeta
polnaya prichem. dumala, bystro sdelau, fig tam...
chto za zaluba, na python polychilos' yskorit'?
What do you need to speed up? Brute force method is not acceptable - too many combinations.
zborishe tormozov
This comment has been hidden.
This comment has been hidden.
And C#, PHP, Ruby, Typescript.
This comment has been hidden.
Haskell is not affected.
Unless
1e14, with specific provisions to sometimes ask for numbers with no solution, is not good enough.This comment has been hidden.
Fixed for Python/CoffeeScript.
Haskell fork adding a fixed test case that should time out for brute-force solutions.
I dont understand how this output should match: The expression (next_bigger_number(10990)) == (19009) is false. Shouldn't it be: (next_bigger_number(10990)) == (19090) Already resolved before posting:) while writing LOL
How is this next bigger number?
It should work for random inputs too: expected 63778 to equal 37867
This comment has been hidden.
This comment has been hidden.
Print the input, what was it?
based on that error I assume that the input is '414' and I tested and got '441'.
Pretty sure you're misreading the logs, read this: https://docs.codewars.com/training/troubleshooting/#print-input
This is the input "Test.assertEquals(nextBigger(144),414)" , and on my IDE if I test with '144' I get '-1' . Do you think there is an error on the testing from the kata ? or am I missing something ?
Then you get the same result in your IDE and here, there is a problem with your code, because, you can see the next bigger number you can form with the digits of 144 is indeed 414.
You are right, I totally misunderstood. Thank you!
This comment has been hidden.
No, it's next bigger, not biggest.
Expected: 1234567908 But was: 1234567980
Can someone hint me which is original number?
Did you try printing it?
Oh, thanks.
This comment has been hidden.
This comment has been hidden.
Print the input, check the posts below.
The problem below is a little different, regarding the my first question (my answer is more suitable for the task). But I realized that my algorithm is still not correct. Thank you.
I meant posts like 743627PDSB's one. He had the same problem.
Testing for 263457394695 It should work for random inputs too: 263457394965 should equal 263457394956
What? What is the logic determine the next big number? Unclear
What's unclear? 263457394956 is the next bigger number with the digits of 263457394695. 263457394965 > 263457394956 so it's not the next bigger number.
I clear! Thanks!
whenever a number passes the 17 digit the result goes crazy, for example the result is 123456789 my code goes well up to 12345678, when I add 9 the result became -51435483512, I'm using c
Ruby 3.0 should be enabled.
Enabled in this fork
My solution fails for only 1 test input: 59884848459853 I have been burned so many times by the lack of quality checks and mistakes in codewars katas.
For those stuck, i found it helpful to visualize whats happening with a pen and paper.
One of the best comments in this section: personally I prefer to juggle things in my mind, but I see the value of your suggestion 👍
This ^^
This is not about refactoring, please remove the tag.
see here
This comment has been hidden.
Brute forcing your way by computing all the possible combinations before and filtering them more than once will never pass.
Think how you would solve this problem as a human instead :)
This comment has been hidden.
Glad you enjoyed it :)
This comment has been hidden.
Thanks for your appreciation🙏
By rearranging for 2071 shoudl be (7210) which is the greatest number possible..Make your description clear..
That's not what's asked. 7210 isn't the next bigger number.
Not a suggestion.
The description tells to write a function which takes a positive integers as input as return the maximum number formed by rearranging it's digits..(2017)= (7210)?
Where do you see words like greatest or maximum ??? These are all from your imagination. Read the task description again...
Next bigger number!...Sorry my bad..
This comment has been hidden.
Great kata, gives really good experience. For solution ideas try looking at test results..)
Right now I am going nuts, but deep inside I know that this one is reallz a great excercise :)
New test framework should be used in Python.
.
This comment has been hidden.
Perhaps you could try to optimise your solution.
VB Translation ready for review.
.
I think there is an issue with random test cases. The value wanted is less than the original value.
Here are some examples of what I am talking about
1234567980 should equal 1234567908 59884848495853 should equal 59884848483559 75530899033 should equal 75530893039
Please correct me if am wrong.
Thanks have a great day
hi,
Considering the number of completinos in JS, there are close to no chances that the tests are incorrect. Keep in mind you didn't provide the input, so there is nothing to tell, right now. What if the input was 1234567890? Then your code is giving the wrong answer, that's all.
Alright thanks! I see what you mean. My bad for not properly checking.
Hi, Because next bigger int for (1234567890) inserted is (1234567908), but not (1234567980) =) You need to re-check your algorithm or code
This comment has been hidden.
Sigh: read the other comments - it is about finding the "BIGGER" (ie: next step in a lexicographic order), not the "BIGGEST".
oh ok sorry, thx for explaining!
This comment has been hidden.
the answer should be -1 because there is no bigger number than 84 possible with the two digits 8 & 4
according to the instructions if there's no other possible bigger number the return should be -1
The description clearly says that
-1is expected in such cases, and the previous responses have already clarified this too. Closing.This comment has been hidden.
This comment has been hidden.
Still the same problem, it makes out through simple tests but throws the same problem again - -1 expected 9876543281 provided. Just don't want to give up on these points I could get from this Kata, so I can't check out all of the tests myself, so I don't know whether I did smth wrong and I can not find a mistake or is there a mistake in tests since ppl says it happens from time to time.
Though I pretty much lost all of the points for all of my failed attempts since basic tests told me it's ok and working fine -_-
Well, what changed? Did you print the input? You keep showing us the output, but that's meaningless without seeing which test you're talking about.
No.
You don't lose any points for attempting a kata.
You have all the input you need to find out where the problem is. If it's supposed to be -1 - then you don't need another part of the code since it's the only rule to get -1. If only you can't see the spoiler part but it is said to mark parts of solution as spoilers
It's like talking to a wall...
Literally you haven't provided a single input parameter yet.
Anyway, good luck trying to debug it, and make sure to read the article Chrono linked.
You're right, it's like talking to a wall, you don't even understand what I am asking for but still trying to look cool while not being able to help.
How could anyone understand what you're asking for? All you're saying is that some test is saying some number should equal -1. So what's the initial number?!
9876543281 = your result, -1 = expected result. And what's the initial number you're working with? No one knows, because you're not saying it.
Oh yeah it's very cool repeating the same things and being ignored. If you actually spent 5 minutes on the article Chrono linked, I'm pretty sure you'd find your answer, or how to look for it.
Bottom line: the tests are correct, your code is wrong, and you should try fixing it. If you're REALLY sure your code is correct, you can post your code here as shown in the same article.
Are you really so much dumb? I don't know the initial number cause I can't look at ALL TEST CASES, it's prohibited unless I forfeit the Kata which I don't want to. So I asked if any1 can find a problem in logic, but you're too much dumb to understand what I am asking for.
Now since I forfeited this Kata I can say that the case is assertEquals(-1, Kata.nextBiggerNumber(9876543210L)); which is just as dumb as you're. It is supposed to have a note at least that number can be given in such form since all examples use an ordinary numbers without L at the end, cause it's quite dumb since the function itself says that initial number is long type.
I don't know what you're on about, you're just spewing words at this point...
But here's the secret: you can PRINT THE INPUT. For java, that's using
System.out.println(arg).What IS dumb is your inability to read anything... It's all explained in troubleshooting article, but you're too cool to read it apparently.
Btw, for a dumb people like you're: The task says
Create a function that takes a positive integer...
Now you tell me since when 987654321L is an integer, mr. ThereIsNoMistakesInTests?
Please don't escalate this any further. Let's see:
That
integerdoesn't mean data type, it means it's a whole number (a positive one), without decimals. And you can see the initial code:Just make a note in the descriptiion of the task or make an example with literals since it's etremely decieving in a way it is now.
987654321L is the standart way of marking number as LONG. Here's the initial function signature in java:
public static long nextBiggerNumber(long n). Do you now see it? The description is written universal for 10+ other languages, not all of them have longs, that's why there's function signature given which you must've changed for no reason.Seriously, get a f..ing grip man. I understand stupidity has no limits, but come on... Don't be that example.
Well, you're an example yourself
Both of you, stop it, now.
The point is that 987654321L is decieving since it has literal which never were noted to have. I don't know for sure but I guess not every single language have literals like this, just make a note in a task
it's not a "litteral", it's a notation that implies this is a "long" integer (as opposed to an "int" integer, let's say). There is nothing ambiguous here, as long (pun? x) ) as the user looks at the signature in the initial solution and knows the basic data types in Java (which he should know already, for a blue kata).
cheers
This comment has been hidden.
cr_assert_eq(next_bigger_number(2017), 2071);It's not the biggest, it's the next bigger, and it's been said many times below.
And about the data type, there is an open issue about that (hopefully fixed, copy your code if you had any, click reset, paste it and try again), so closing.
This comment has been hidden.
Did you got response: "For some confidential reasons, your solution won't be accepted?"
We can't guess the exact reason, please tell us the error you're getting.
Hi. The error was that it was unable to find the "findPermutations" method
No, that's not the problem, you're missing some
import. Even when added the missing import, your code time-outs when trying the full test suite.thx
Test cases appear to be broken for Typescript. Here are a few examples:
expected nextBigger(2107) to equal 2071 expected nextBigger(214365879) to equal 123456798
In both cases the expected number is less than the original.
This comment has been hidden.
That was precisely my own experience a few years ago - glad you enjoyed it as I did :)
This comment has been hidden.
Thanks for your feedback :)
This comment has been hidden.
Your algorithm is fairly inefficient, that is correct: ask yourself how would you solve it as a human and it might bring you on the right path :)
Very instructive Kata! Arigatou gozaimasu!
Ie, ie betsuni ken-san.
All those hours watching anime are finally paying off. At least when I see a common, short sentence.
Subarashi, Chrono79: ganbatte!
This comment has been hidden.
This comment has been hidden.
It is not an issue and if you bothered reading messages before that, you would know the problem is in your very inefficient code (and please format it when posting it).
For Rust
A very minor issue where tests generate 'unused mut warning' for the line
let mut slice = &mut digits[i..];No longer an issue.
This comment has been hidden.
PLease Don't say it's indent issue and marked as resolved . Please be helpful here. IT's working code. Thanks
No. Resolving.
It's not enough. You need to pass 100% of cases to complete the kata.
So, are you mistaking, or is it working code? Hint: it's not ;)
Your code fails following test case:
Test.assert_equals(next_bigger(890),908). For input890it returns980, but correct answer is908. Debug through it locally in your IDE and see how your approach solves the problem incorrectly.soumya_kathua: read my reply to your post in this kata: https://www.codewars.com/kata/51ba717bb08c1cd60f00002f/discuss#5fac3d4097ead20032bc4711 it seems you haven't read it.
Working in C#. Code on my desktop runs in 74ms and timesout in codewars. Is this an issue that others are noticing?
Yes, this issue is quite often observed by users who managed to come up with inefficient solution.
Try running following test case locally:
Assert.AreEqual(9000000001, Kata.NextBiggerNumber(1900000000));Thanks! I finally ended up solving it my code was more inefficient then I thought.
I got all of them right except the last one I got with 19090 isn't that the next bigger number?
I have written it in Java
Maybe it's not the last one, just the first test that failed. What was the input number?
sorry I read it wrong :-) found the problem
assertEquals(19009, NextBiggerNumber.nextBiggerNumber(10990));
This case drives me crazy :-)
Python Test Passed Test Passed 7210 should equal 2071 Test Passed 441 should equal 414
The solution that the program gives is not the biggest combination in some cases
It's not the biggest, it's the next bigger, and it's been said many times below.
I came to the discussions beacause of this issue. Turns am just an idiot, and many people asked this too. Is this beehive mind in play?!!
This comment has been hidden.
Your code times out for much smaller inputs, like for example
19876543210.Generally this problem can be solved without generating or enumeration of permutations. It's heavily affected by arrangement of digits in the input, and solutions based on permutation generators can solve some specific large inputs very quickly, but also can take forever for some specific small numbers. "Correct" solution does not rely on lists of permutations, but it should produce answer by (more or less) scanning through digits once.
Thanks a lot. I thought about such compare, but don't really know how to realize it. Will try later
I also was stuck after trying a brute force permutations-based approach. But if you look closely there is a fairly easy approach along the lines @hobovsky suggested. My starting point so far is: is the N-1th digit is smaller than the Nth digit (with N = the number of digits in n), swap them. Iterating N times this will yield the solution for some cases, not all. After that you may want to think recursively. Hope this helps without giving away too much.
There is a trivial solution, that fails around n=10^9 due to runtime limitaitons.
And there is an algorithm that you can easily demonstrate on paper for numbers around n=10^100.
Not a suggestion.
There is this number in 'biggerTests' 59884848459853, isn't it too long for long? I mean when i try to test this one code in my IDE with this num it just throws an error. Anyway i guess permutations approach is not well for this kata...
If by
longyou mean 64 bit, signed integer (you did not mention your language), then 59884848459853 is not too big. It does not throw error in my IDE."Permutations approach" is very appropriate for this kata, just not iterating through all possible permutations.
Consider the number being a string. I successfully tested with rand(10 ** 1000,10 ** 2000);
A question. When my code (in python) times out in testing after 12s, I don't see any partial stdout/err output. I've tried flushing sys.stdout, writing to sys.stderr. Nothing seems to help. How can I see what test I'm failing on? I pass the first handful of test cases but don't see their stdout.
I don't think you can when you timeout :( If you just want to see the test cases then do:
you can, using:
Try
print(n, flush=True). I do not recall having any special problems with printing even when tests time out, but I do not solve Pytohn kata that often, so I might miss something.o_O
Solved! The print(...,flush=True) did it. I was doing a print(...) ; sys.stdout.flush(). Not sure why that didn't work, but I'm happy.
Thank you for your help. Now off to fix the bug.
This comment has been hidden.
Just check how long your solution runs for input like
1987654321.There is hardly anything optimised there (if not for what
permutationsmight do under the hood instead of a function written to do the same by you) and it is actually rather brute-forceish; try to ask yourself how you would solve it as a human and I am sure you would not compute each single possibility, sort them, etc.Also, please, try to format the code properly when posting it :)
[Incidentally, sorting
str(n)would probably be much better than sortingresult, but please do not go that way]This comment has been hidden.
It's the next bigger number, not the biggest number, and it's been asked and answered before (for instance GolivetsAndreu's post). Try reading the posts already here next time, sometimes they have already the answer you look for.
This comment has been hidden.
If tests say your solution is wrong, how can you know it's correct?
I just retested my Python solution and encountered no broken case.
Potentially helpful FAQ: https://github.com/codewars/codewars.com/wiki/Troubleshooting-your-solution
This comment has been hidden.
Print the input too, those are only your wrong answers and the expected ones. In the first case, the input value was 1234567890, your code returned 1234568079 which is greater than 1234567908.
It's difficult to tell if these expected outputs are correct because you did not provide inputs. All we know from the log you pasted is expected answer, and actual (yours) answer. But without knowing the input, we cannot tell which is correct.
Except two of them.
1234567890, and59884848459853If I got test cases correctly, then indeed the next bigger number with the same digits as
1234567890(input) is1234567908(as expected), and not1234568079, as your solution apparently answered. The same thing applies to the second test, and I think it will be safe to assume the same for random tests.Your solution has a bug, and your answers are not correct.