2
$\begingroup$

There are so many sequences here already, I cannot guarantee that this is new. At least, I haven't found anything like this yet. But I can assure you that you will not find the sequence on OEIS.

$$ 0, 2, 3, 4, 10, 18, 35, 40, 54, 70, 88, 144, 172, 196, 240, 288, ...$$

What is the principle? What is the next number?

I cannot estimate how difficult it will be to solve. So, on request I can try to give hints without revealing everything.

My description of the principle contains eleven words.

Edit:

Sorry, I messed up the sequence, but @codewarrior0 found out the principle, nevertheless.

Edit 2: unbelievable..., this seems to be an ensorcelled sequence... I guess, again I did a mistake. The correct sequence should be:

$$ 0, 2, 3, 4, 10, 18, 35, 40, 63, 80, 121, 132, 143, 168, 225, 240, ... $$

But the 17th number is not 288 as the 16th number in the initial wrong sequence above.

$\endgroup$

1 Answer 1

5
$\begingroup$

Probable answer:

Each number in the sequence is equal to the product of that number's index and the total number of holes in the digits that previously appeared in the sequence. There is a mistake in the sequence at index 9, which counts the element at index 8 as having a single hole instead of two. There is a second mistake at index 13, which changes a single digit and writes 172 instead of 182.

    Errors:                                     !             !
    Index:              1  2  3  4  5  6  7  8  9 10 11  12  13  14  15  16
    Sequence [sic]:     0  2  3  4 10 18 35 40 54 70 88 144 172 196 240 288
    Holes (previous):      1  0  0  1  1  2  0  1? 1  1   4   2   0   2   2
    Holes (cumulative): 0  1  1  1  2  3  5  5  6  7  8  12  14  14  16  18

Since this sequence seems to invite a lot of mistakes, here is a Python program to compute it:

#        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_holes = [1, 0, 0, 0, 1, 0, 1, 0, 2, 1]
def holes(n):
    return sum(_holes[int(digit)] for digit in str(n))

total = 0 sequence = [] for i in range(1, 25): sequence.append(i*total) total += holes(sequence[-1]) print(sequence)

The program produces this sequence:

$0, 2, 3, 4, 10, 18, 35, 40, 63, 80, 121, 132, 143, 168, 225, 240, ...$

Whose next term is:

$289$

$\endgroup$
4
  • 1
    $\begingroup$ Wow, this was fast! Sorry, I messed it up. You are absolutely right, this principle was the idea. Thank you for spotting my mistakes. Now, I double and triple checked, but my corrected sequence looks different to your corrected one. I will correct my question. Fortunately, the final result is the same ;-) rot13(Ol gur jnl, gur svefg uvag jbhyq unir orra gung gurer vf n uvag va gur gvgyr ("rapybfrq") naq gur frpbaq bar gung erfhyg vf sbag qrcraqrag: Gur pbqr sbag unf ab "ubyr" va gur sbhe, ohg gur zngu sbag unf.) $\endgroup$
    – theozh
    Jul 10, 2023 at 6:36
  • $\begingroup$ sorry, again. Your finding about the principle is absolutely correct. But could you maybe please check your corrected sequence again? I again did a mistake, but hopefully, in my corrected question there should now be the "really" correct sequence. $\endgroup$
    – theozh
    Jul 11, 2023 at 7:38
  • 1
    $\begingroup$ Sure! I've corrected my presumed sequence, and even added a small program for computing it. $\endgroup$ Jul 11, 2023 at 7:53
  • $\begingroup$ perfect! Thanks a lot! Now, this sequence can rest in peace ;-) $\endgroup$
    – theozh
    Jul 11, 2023 at 7:54

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.