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 the name of the person who will drink the n-th Cola at the vending machine

Sheldon, Leonard, Penny, Rajesh and Howard are in the queue for a "Double Cola" drink vending machine; there are no other people in the queue. The first one in the queue (Sheldon) buys a can, drinks it and doubles! The resulting two Sheldons go to the end of the queue. Then the next in the queue (Leonard) buys a can, drinks it and gets to the end of the queue as two Leonards, and so on.

For example, Penny drinks the third can of cola and the queue will look like this:

Rajesh, Howard, Sheldon, Sheldon, Leonard, Leonard, Penny, PennyWrite a program that will return the name of the person who will drink the n-th cola. The input data consist of an array which contains at least 1 name, and single integer n which may go as high as the biggest number your language of choice supports (if there's such limit, of course). The output data returns the single line — the name of the person who drinks the n-th can of cola. The cans are numbered starting from 1.

Good luck, and happy coding!

*Thank you to CodeWars, who has licensed redistribution of this challenge under the 2-Clause BSD License!*

*Want to propose a challenge for a future post? Email yo+challenge@dev.to with your suggestions!*

## Discussion (20)

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 log

_{2}(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

Erlangversion. 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

thinkgot it right, at least:Benchmarking with

`timethis`

in`Benchmark`

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 levelbeforeso 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.EditLooks like Corey figured out the same thing, but with more math.Not a better solution compared to @alvaromontoro but here is mine in js

PHP:

It returns

`b`

for`cola(10, array("a", "b", "c", "d"))`

which I think should return`c`

.Thank you, that's a good catch - I fixed this by replacing

`floor()`

with`round()`

.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.

My entry, written in Java:

Ruby.

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:

Some Smalltalk

Defining a subclass of Array that would act like an "infinite collection" (just because it is fun).

To execute:

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!