Thank you for pointing this out. I wrote this as my first kata. Rereading the code, I understand what my original intent was with the "batch test" and why it is flawed.

I've fixed the tests -- and I did it without BigInt.

If you're able to use BigInt to solve the Kata -- fine.

Otherwise, I can update the description to indicate that BigInt is not allowed since part of the challenge with this Kata is not having BigInt support as is the case for some of the other languages.

what you mean unfair to other languages ? java 11 and python 3.8 both have it

you only need to enable node 10/1 2

142857 is 5-parasitic but 142857 ends in 7 NOT with 5 as the title "n-parasitic ending in n" and the "Special Parasitic Numbers" section clearly calls out.

I added the 142857 in a new "clarifying anti-example" section in the description in hopes of improving the understanding of this kata's requirements. I resisted creating this out of concern that I was creating a "wall of text" that either won't get read or that otherwise discourages kata attempts.

My favorite kata on here are terse, deceptively simple and their solutions profoundly satisfying.

google is your friend... https://en.wikipedia.org/wiki/Hexadecimal

(and no need to scream like that... x) )

I see, so I assume that I'm supposed to use A-F. The Hex function in python doesn't do that - is there something built in?

well you can always rely on printf %x (or %X for uppercase) : "%x" % my_digit

Otherwise (list(range(0,10)) + [char(c) for c in range(ord('A'), ord('Z')])[my_digit] will work up to base 36, but I think you were looking for the first one.

I don't understand what you mean by "The Hex function in python doesn't do that". hex(10) '0xa' hex(12) '0xc' I get the same on Python 2.7 and 3.6. Or did I miss something?

Fixed. You might need to reset it to see the change. Or just change the Result to ExpectedResult in the sample tests.

Thanks a lot, Blind4Basics! My fault.

Since there is only a fixed set of answers, I won't give it to you. Instead, I will show what you get when you mutliply your answer by 3...

1057262010144124151298821193
x                          3
===========================
31057260303cc36c3f37c98634b9

You seem to be off to a good start reading from left to right. The product starts with 3, then 105726 which match the digits in your answer... but then the next digit in the product is 0 and the next digit in your answer is 2 -- so it fails from that point on. You should also note that your answer contains no letters -- most hex solutions are likely to contain some letters.

I don't know what your algorithm is, but from the lack of letter-digits [a-f] in your solution, I would guess that you wrote an algorithm that solved for base-10 and have a hardcoded 10 where you should have the number-base argument.

Good luck and I hope you're getting some satisfaction from attempting this kata.

Thank you for response, it really helped:) I forgot to convert remainders that are greater than 9 to letter-digits

If you don't even provide the most simple things like error message and your code, how do you expect people to help you?

I don't see how this isn't an issue. It seems like the test cases are broken.

CODE: function calculateSpecial(lastDigit, base) { return 1 }

ERROR MESSAGE: TypeError: s.charAt is not a function at test at run at Test.describe at /runner/frameworks/javascript/cw-2.js:159:11 at Promise._execute at Promise._resolveFromExecutor at new Promise at Object.describe at /home/codewarrior/index.js:53:6 at /home/codewarrior/index.js:63:5 at Object.handleError

"calculateSpecial" is supposed to return a string (see the second sentence of the "Challenge" section in the kata description.) If you return a number instead of a string, you will get this kind of error. There are base-16 answers require letters in the resulting answers, so all expect strings.

I could code the javascript test implementation to coerce the type to string, but base-10 is the only case where that makes sense.

[Edit] It has been a while since I coded it, but as I recall, the javascript test validates that the answer satisfies the criteria rather than that you get the same result as an official algorithm implementation (this is in constrast to the many kata that are written that way.) Barring that the official algorithm could be buggy, this has the benefit that Code-Warriors could completely view the entire javascript test code without seeing the working solution.

[Edit] Because of this, I'm considering adding a type-test for each of my javascript kata.

apart from the base 2, it would be quite easy to implement random tests for the other bases up to 16, without big modifications of the test suite, tho. That would be a good addition to your kata!

That's almost it: the test cases were put in three distincts it wrappers (base 10, 8 and 16), and the tests won't start the next it if an error was found (that's originally designed to avoid getting minutes of testing and tons of bad reports when a basic function is wrong). You can reproduce the tests without the wrappers in the sample test cases and check your answer (then of course you won't get to know immediately if it's wrong but you can notice bad patterns and check by hand)

Just a hint if it's of any help; a number can never start with leading zeroes.

I thought the kata and its examples were quite clear, but you're not the only one that has struggled with the kata's requirements. So I'll apologize in advance for what might seem like excruciating detail as I try to provide necessary clarification.

A multiplication expression can be defined as having 3 parts: a multiplicand, a multiplier and a product. As a math equation, we would write: multiplicand * multiplier = product

For our purposes in this kata, the multiplier is clearly N. The kata wants you to find/compute a multiplicand such that:

1. The multiplicand's rightmost digit (the digit in the ones' place) is N.
2. The product contains all of the same digits in exactly the same order as the multiplicand except that what is the trailing/rightmost N-digit of the multiplicand has shifted to become the leading/left-most digit in the product.

Looking to your 7 base 16 number -- it satisifies the requirement: 1024E6A17 * 7 = 71024E6A1 I believe the official tests accept this as the only answer for N=7 in hex.

The rest of the examples provided in your post, though, do not satsify the kata requirement -- the numbers for the multiplicand do not end in N.

The N = 2 base 8 answer IS NOT 25

In base 8, 2 * 25 = 52, which almost seems to satisify the kata; except, that this has reversed what is desired by the kata -- in this case, the product ends with N in the ones' place instead of in the one's place of the multiplicand like the kata seeks. (However, this might make for an interesting sub-kata/experiment. I suspect that there are likely few solutions that shift in this fashion.)

There are several approaches

One way is to consider how we would progress if we did it by hand. For N=4, Decimal, I did:

  4
* 4
====
 16

So, the last digit of the product must be 6, and we must have a 1 carry. Because of the same-order-digit requirement (in bullet point 2 above) we could proceed to find the next digit by using the information in this paragraph like so:

 1
 64
* 4
====
256

So from there, we get the last two digits of the product are 56 and we see that we have a 2 carry.

Proceeding similarly from there, eventually ends up with: 102564 which is the answer for the multiplicand that the kata is searching for in the Decimal N=4 case.

How do we know when to stop? That's left up as something for the reader to discover.

Brute force doesn't generally seek to exploit relationships or break the problem into smaller pieces. By "brute force" I mean something like the approach a colleague used in his attempt to solve for just the base-10 parasitic number ending in 6. His approach was to start with 6 and increment that by 6 and then test the digits. Of course, he never completed the puzzle and that approach was doomed.

There's only a fixed set of answers, so I chose not to show expected values. I'll give you a couple of hints:

• Most of the numbers are very large.
• Think about how you would do the math a digit at a time.

Good luck! Thanks you for your interest.

EDIT : Forget this comment. In fact my algorithm seem to be completly wrong.

I hope you're feeling engaged not discouraged. This is one of those puzzles that I feel gives a sense of accomplishment after completing it.

Don't know if i will be happy or if i will be sad thinking about the time spent on this simple exercise... I now got a solution in full math that seem to work. My first attempt manipulated strings...

But ! Some tests always fail (22 tests pass/28). The 6 faillings test are the 6 in base 16 where n >= 10. For exemple : calc(10, 16) return me "1019c2d14ee410" which is "1019c2d14ee4" + "10"

EDIT : In fact, i implemented https://oeis.org/A092697 so it logicaly fail. Does i should implement https://oeis.org/A128857 instead?

Is it possible to know the result of calc(10, 16) ?

These are interesting links. I'll give a big algorithmic hint that I may later flag as having spoiler content.

Let's take the simplest base-10 problem: the 4-parasitic number ending in 4 is 102564 -- let's pretend we don't know the answer and see if we can figure out how to derive the 10256 part.

If you wrote the problem out starting at the right and worked left:

 4
x4
==
16

This means that a number ending in 4 times 4 gives a product that ends in 6, so 6 is the next digit to the left of 4. We also figured out that we have to deal with a 1 carry. Remember that the same set of digits are going to be in the top and the bottom, just shifted and the 4 rotated around to the beginning.

So in the number on the top, write a 6 with the 1 carry over the top to create the next iteration for the multiplication:

 1
 64
 x4
===
256

So now we know the two digits to the left of the 4 in the multiplicand is 56, with a 2 carry. So expand the next digit out (note the carries across the top)

 21
 564
  x4
====
2256

I'm going to quit spelling the findings out and just write the rest of the iterations out:

 221
 2564
   x4
=====
10256 <-- this is the answer for what's to the left of 4, but if we continue...

1221
02564
   x4
=====
10256 <-- almost same answer - the only difference is in the carries and this time the lead digit rendered a 1 with no carry.

01221
102564
    x4
======
410256 <-- the final product indicating the final answer has been reached for 4-parasitic ending in 4.

The number is therefore "102564"

The rest is really just a coding this up and accounting for which number-base you're dealing with.

Yes, this is the exemple written over wikipedia. I base my first attempt on this algorithm with this exemple. It's work well for calc(4,10) and calc(4,16)

But now, let's try this algorithm with other number in base 10 : 2. calc(2,10) should result 105263157894736842 (Verify thx oeis.org/A092697/list)

If you wrote the problem out starting at the right and worked left:

2 x2 == 4

This means that a number ending in 2 times 2 gives a product that ends in 4, so 4 is the next digit to the left of 2. We also figured out that we have to deal with a 0 carry.

So in the number on the top, write a 4 with the 0 carry over the top to create the next iteration for the multiplication:

0 42 x2 === 84

So now we know the digit to the left of the 4 in the multiplicand is 4, with a 8 carry.

80 42 x2 ==== 84 <-- almost same answer - the only difference is in the carries.

And If i continue i have an infinite loop.

So where's the fail? :x

The reason I chose the '4' problem is that it's the shortest in base-10. Your problem is that 8 isn't the carry, it's the next digit; 0 is the carry. In multiplying the next digit and adding the carry, the product will always be 1 or 2 digits; the digit in the tens-place is the next carry and the digit in the ones-place is the next digit.

I've worked the first several out below.

 2
x2
==
04
 ^--- 4 is the next digit, since the product < 10, we have a 0 carry

 0
 42
x 2
===
084
 ^---- this 8 is the next digit, it isn't a carry
            |
 00         |
 842 <------/
x  2
====
1684
^------ this 1 *is* a carry, and 6 is the next digit, 2 * 8 + (0 carry) = 16

 100
 6842
x   2
=====
13684
^------ this 1 is the carry, 3 is the next digit (2 * 6 + 1 == 13)

 1100
 36842
 x   2
 =====
073684
 ^------- product 2*3+1 -> 7 next digit, 0 carry
 
 
 01100
 736842
 x    2
 ======
1473684
^---------- 1 is carry, 4 is next digit (2*7+0 = 14)

101100
4736842
x     2
=======
9473684
^------------ 9 is next digit, 0 is carry (2 * 4 + 1 = 9)

 0101100
 94736842
x       2
=========
189473684
 ^----------- 8 is next, 1 is carry (2 * 9 + 0 = 18)

...and so on.

All you have left to determine is the stopping criteria and generalizing this algorithm for any number base. This should get you really close without taking the rest of the fun out.

Thanks for your help. :)

I did not arrive to make it work with your explanation but after a quick look to your solution, i made almost the same thing. My concern was probably the stopping condition.

But i finish the exercice. How?

After for modification to my algorithm, i was able to get to the response of calc(10,16) and calc(11,16) (from the attempt) and I notice that i was exactly the same that the results i get with my pure math function except the last number that was not in the right base. So i simply change into the right base the last number return by the fonction.

It solve the exercice but :

• the A092697 specify that's only for number < 10
• There's also this interesting link : https://en.wikipedia.org/wiki/Talk%3AParasitic_number#n_.3D_5

I am far from being good at math and I may have misunderstood some things in the links I have given but the results for n> 9 and n = 5 in base 10 may be wrong.

The exercise remains interesting. :)

Finding smallest n-parasitic numbers in base b isn't so difficult too as you only need to search a numerator between n + 1 and b wih the same denominator.