Good morning! We're back with another challenge which comes from AlexisHappy on Codewars. Today, you are asked to write a program that will return ...
For further actions, you may consider blocking this person and/or reporting abuse
JavaScript
The way it works, the series follows an exponential pattern in which the first iteration has n elements (5 in this case), and from then on each iteration has double the elements than the previous iteration:
Iteration(0) = S, L, P, R, H (5 elements)
Iteration(1) = S, S, L, L, P, P, R, R, H, H (10 elements)
Iteration(2) = S, S, S, S, L, L, L, L, P, P, P, P, R, R, R, R, H, H, H, H (20 elements)
Iteration(3) = S, S, S, S, S, S, S, S, S, L, L, L, L, L, L, L, L, ... (40 elements);
Iteration(4) = S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, ... (80 elements)
With that in mind, it is possible to calculate in which iteration we are by doing log2(number / 5), and from there we can get which element within the actual iteration we need to check. After doing some numbers, trying to figure out the pattern, and all that jazz, I think this may work... although I haven't fully tested it.
Live demo on Codepen.
I like what you are doing here. Kudos :)
It seems to work. I tested it (ported to Erlang) with N up to 22 on a queue of 3 people.
I couldn’t figure out the formula like @alvaromontoro did, but here’s my blunt Erlang version. It was really easy to write and it still runs under a second for N = 10 million:
Iterating over the whole queue is slow when the number is really large. I wasn't able to find an exact formula, but I was able to find a good upper bound from which I can find the exact solution in linear time.
The solution is in Perl:
Benchmarking is easy using the Benchmark module:
The output shows a table ordered from the slowest to the fastest.
Unfortunately, it breaks for longer sequences, as the rounding error becomes too large. Switching to arbitrary precision is too slow, increasing the upper bound helps - the failures are easy to detect as the function returns
undef
instead of an element of the queue.So I think I was able to get this with an exact calculation. I thought it was going to turn out to be pretty convoluted, but I guess it's not. I think got it right, at least:
Benchmarking with
timethis
inBenchmark
got me this result:Basically, I just keep track of how many nodes there are in a tree structure which represents the doubling of the people in the queue. In each level of the tree, you double the number of nodes in the level before it, but we want the running total so far (which I call
$last_index
above because that is the index of the last node in the level where the$n
th cola would be).Once you figure out which "level" of the tree the
$n
th cola would be, you get the last index of the level before so that you can zero out the current level and any indices there. That makes it easy to figure out "where" on the current level of the tree the$n
th cola is, and you just divide by the depth of the tree so far to turn that into an index that works on the initial array. Subtract one to get the 0-index value into the original array.Edit Looks like Corey figured out the same thing, but with more math.
My entry, written in Java:
This was one of my favorites in a while!
I had a feeling I could get this answer in constant time, by just 'mathing' the value out! So I got out my good old pen and paper, and started working through it!
The repeating pattern of the list made me start thinking of the long list in cycles. Where one cycle was each person in line going as many times as they are supposed to in that cycle. I thought I would be able to determine how long the list would need to be to 'index' into it with the
soda number
, based on how many cycles it took! And we can! Since the cycles lengths follow the patter of: P, 2P, 3P, etc. I knew this could be represented as a summation formula, and I was pretty sure it had an algebraic solution! After a bit of googling I was able to find it! Applied to this problem the formula is as follows:From here, I wanted to kinda reverse that formula. I wanted to know how many cycles it would take to achieve a specific length. After re-arranging that formula I was able to use the quadratic equation to rearrange, and solve for C, given Length and P. The quadratic formula gives two answers, and we are able to throw out one since we can guarantee it is negative and not relevant to our problem.
So now we have this!
So now if we take the soda bottle number input as the Length, and the number of people in line as P, we can get a discrete value of the number of cycles it will take!
To figure out which person got the bottle I really only needed to index into the last cycle. And know I was able to figure out which cycle that was!
From here it was just some index math, to figure out which person/index we were looking for!
I wanted to make sure this solution worked, so I also wrote an iterative version to compare! I wrote a quick main function that compares the two results and they were equivalent for everything I tested! I also timed the two versions to see the speed differences, and as expected the constant time solution is orders of magnitudes faster than the iterative solution!
Here is my full rust solution and tests!
Elixir:
Not a better solution compared to @alvaromontoro but here is mine in js
PHP:
It returns
b
forcola(10, array("a", "b", "c", "d"))
which I think should returnc
.Thank you, that's a good catch - I fixed this by replacing
floor()
withround()
.I'm still not sure it's correct.
cola(9, array(1, 2))
returns 2 instead of 1.Hm, you're right. It looks like I didn't test it thoroughly enough yesterday, and the tests I did came back with the right answers for the wrong reason. I'm trying to get better at solving math problems so I'll look more into this when I'm off work.
Some Smalltalk
Defining a subclass of Array that would act like an "infinite collection" (just because it is fun).
To execute:
Ruby.
I didn't get the notification for this challenge even when I'm following dev.to staff
Oh huh, I didn't notice but I didn't get my notification either 🤔
And while we're on the subject, it would be really cool to be able to follow specific series! So I could just follow this series of posts!