[Question]
  [
**This is a [cops-and-robbers](/questions/tagged/cops-and-robbers "show questions tagged 'cops-and-robbers'") challenge. The robbers' thread is [here](https://codegolf.stackexchange.com/questions/167597/hardcoding-the-cops-and-robbers-robbers).**
An interesting question to think about is the following:
> 
> If I have a sequence of numbers how many of them do I have to provide before it is clear what sequence I am talking about?
> 
> 
> 
For example if I want to talk about the positive integers in order starting from \$1\$, I could say \$1,2,3, \dots\$, but is that really enough?
I have one way of answering this question, and being a code-golfer it involves code-golf. You have provided enough terms of a sequence if the shortest code that produces those terms produces all the terms of the sequence. If we think about this in terms of code-golf, this would mean you have provided enough test cases such that the shortest code that passes the test-cases does the desired task.
## Challenge
This challenge is a [cops-and-robbers](/questions/tagged/cops-and-robbers "show questions tagged 'cops-and-robbers'") challenge. In which cops will be presenting test-cases and robbers will have to find a shorter way to spoof the test-cases other than the intended sequence. Cops will present the following things:
* A piece of code that takes a non-negative integer as input and produces an integer as output. This code will define your sequence. Your code does not need to support 0 as an input, opting to instead take 1 as the smallest input. It should be clear if this is the case in your answer.
* Any relevant platform or language requirements that might affect the output, for example the size of longint.
* A number \$n\$, along with the first \$n\$ terms of the sequence as calculated by the code. These will act as "test-cases".
You are encouraged to explain what your sequence does and link OEIS if it exists, however it is your code that defines the sequence not the description.
Robbers will be finding a program in the same language that is shorter than the one presented and passes all the test cases (produces the same output for the first \$n\$ inputs as the cop's code). The robber's code must also differ in output from the cop's program for some number larger than \$n\$.
Cops must be able to crack their own answers before submitting them.
After one week a cop *may* reveal their crack and mark their answer as Safe. Answers marked as such can no longer be cracked.
## Scoring
Cops answers will be scored by the number of bytes with fewer bytes being better. Cracked answers score an infinite score.
  
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents/tree/cquents-0), 4 bytes ([Cracked](https://codegolf.stackexchange.com/a/167643/78410))
```
"::$
```
[Try it online!](https://tio.run/##Sy4sTc0rKf7/X8nKSuX/f0sA "cQuents 0 – Try It Online")
Here are eight (`n=8`) cases:
```
1 1
2 12
3 123
4 1234
5 12345
6 123456
7 1234567
8 12345678
```
Code explanation:
```
"      Stringify sequence (join on "", remove it and see what happens)
 ::    Given input n, output all items in the sequence up to and including n
   $   Each item in the sequence equals the index
```
So the sequence is `1,2,3,4,5 ...`, it is joined on `""` so it becomes `12345 ...`, and `::` means that it prints up to the input.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~66~~ 57 bytes ([Cracked](https://codegolf.stackexchange.com/a/167642/20260))
*cracked by [xnor](https://codegolf.stackexchange.com/users/20260/xnor)*  
*also cracked by [Cat Wizard](https://codegolf.stackexchange.com/users/56656/cat-wizard) before an edit*
```
def f(n):x=n/10-2;return int(x*60-x**3*10+x**5/2-x**7/84)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/PyU1TSFNI0/TqsI2T9/QQNfIuii1pLQoTyEzr0SjQsvMQLdCS8tYy9BAG0ib6huBuOb6Fiaa/wuKQEqi0zQyNRXS8osUMoFaFIoS89JTNQx0TAw0YzX/AwA "Python 3 – Try It Online")
Hello! Here is a sequence to crack for \$n=40\$.
It gives these first 40 elements with 0-indexing, it's not an OEIS sequence
```
[-54, -56, -58, -59, -59, -59, -59, -57, -55, -53, -50, -46, -43, -38, -33, -28, -23, -17, -11, -5, 0, 5, 11, 17, 23, 28, 33, 38, 43, 46, 50, 53, 55, 57, 59, 59, 59, 59, 58, 56]
```
[Answer]
# [Python 2](https://docs.python.org/2/), 44 bytes ([cracked](https://codegolf.stackexchange.com/a/167972/20260))
```
f=lambda n,i=1,p=1:n and-~f(n-p%i,i+1,p*i*i)
```
[Try it online!](https://tio.run/##DYyxDsIgGAb3PsW3kAJSIzVdmuC7oLT6J@0PARy6@OqV4ZbL5dJRP5HHk/YUc0U5Ste4lqXm5fXNhSJvtFOV9qb1pM7VbX5/Bg825KxJzs4Mz2H4rZKHJMjQpWlNmlocMxjEyJ7fi7RmsmrukDJxRS/GgOEBcQ89BCQbtIVS5x8 "Python 2 – Try It Online")
The prime numbers. What sequence could be purer? Or more [overdone](https://codegolf.meta.stackexchange.com/a/14580/20260)? Your goal is to produce the first 50 primes for `n=1` to `n=50`.
The code is a [Wilson's Theorem](https://en.wikipedia.org/wiki/Wilson%27s_theorem) generator copied exactly from [this tip](https://codegolf.stackexchange.com/a/152433/20260).
The different values for the alternative sequence are not due to machine limitations like overflows and precision. No 3rd party libraries.
---
[Cracked](https://codegolf.stackexchange.com/a/167972/20260) by Arnauld, @PoonLevi, and Mr. Xcoder.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~39~~ 34 bytes (Safe)
```
Check[{1,9,7}[[#]],18+Boole[#>9]]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2ar8d85IzU5O7raUMdSx7w2Olo5NlbH0ELbKT8/JzVa2c4yNlbtv6Y1V2BpZmqJQ0BRZl6Jg2NRUWJldJqOgqVl7H8A "Wolfram Language (Mathematica) – Try It Online")
Looks simple, solution should be hard.
1-indexed and \$n = 99\$. This sequence is not available on the OEIS.
```
{1, 9, 7, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19}
```
This above list is equal to:
```
Join[{1, 9, 7}, Table[18, 6], Table[19, 90]]
```
Here's a template for checking your solution: [Try it online!](https://tio.run/##HczBasMwDIDhu55CS2FsxIXmtBXXobSnXcYGgx2MDyaRZ9GmblznMEqfPVN3kNDh@zX4EmnwhTs/B/M0/6YpY5d6wkiZ5mcNbBoN3nzliTR8TkzFfkc@kvUK4IwGw5Y1jHLsI3UHe23UWr3crF04p5rXepeS4EW7du7xLr1IyYzBUcNH5lOxjMsWr2eF403hW5DPWFUyuFlizyFUzgHXtQZwTtZ/tBXH2GKzWoncZ98dqH@4V@@pIJ3S9BOxUB4ulZv/AA "Wolfram Language (Mathematica) – Try It Online")
## Intended Crack
> 
>  The catch here is that the output increases by 1 when the number of digit increases by 1, with the exception for the first three terms; the intended solution has something to do with string conversion.  
> 
>   
> 
>  Hence, reading the documentation on [Converting between Expressions & String](http://reference.wolfram.com/language/guide/ConvertingBetweenExpressionsAndStrings.html), one could find the function [`SpokenString`](http://reference.wolfram.com/language/ref/SpokenString.html).  
> 
>   
> 
>  The solution is simply the length of the spoken-string version of the expression `x^n` for various inputs: [`StringLength@SpokenString[x^#]&`](https://tio.run/##JY1Na8MwDIbv/hVaAmUjLjSnrXgOoT0NxtjoYAejgkntWKT5nAOD0t@eqdtB4kU8z6vWxuBaG6myi9f3yyFO1NWvrqtjKA9D37ju/2R@jimulgclSOdKWP05zU6Jj5lcNF@Bzs5YKcQAGnxJSowc9sFVjbnkcisfr8akiDJ/ynZ9z3BabBFXN9IyyZrWMCrxzr@iIVgXcBkkjFcJL56bIUl44HkNJ/I@QRSUZUoIRF5/UskcQQH5ZsPkfrJV4053N@utj@C6fq4DRDe13wkuvw "Wolfram Language (Mathematica) – Try It Online")
> 
> 
> 
[Answer]
# [Haskell](https://www.haskell.org/), 29 bytes (Cracked: [1](https://codegolf.stackexchange.com/a/167654/56433),[2](https://codegolf.stackexchange.com/a/167709/))
```
a n=n*ceiling(realToFrac n/2)
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P1EhzzZPKzk1MyczL12jKDUxJyTfrSgxWSFP30jzf25iZp6CrUJBUWZeiYKKQm5igUKiQrSBnp6RQex/AA "Haskell – Try It Online")
This is [A093005](https://oeis.org/A093005): \$ a(n)=n\lceil \frac{n}{2} \rceil\$.
Test cases for \$0 \leq n \leq 20 \$, that is `map a [0..20]`:
```
[0,1,2,6,8,15,18,28,32,45,50,66,72,91,98,120,128,153,162,190,200]
```
## Intended solution (20 bytes)
```
b n=sum$n<$show(3^n)
```
[Try it online!](https://tio.run/##VcmxDkAwFAXQ3VfcoQMGhJXVF9iE5KGh0b5KS3x@WQzWczbyu9Q6ELjhdJZKK15jJ0l3tnU0g/MyCdO7/jKCa@E3e8fVyEkwpBgNFhvhcIpPCBg6QOiLLCur4c/Tx@EB "Haskell – Try It Online") Differs at \$ n=23 \$, with \$ a(23) = 276 \$ and \$ b(23) = 253\$.
This function is equivalent to \$b(n) = n\ len(3^n) = n \lceil log\_{10}(1+3^n)\rceil\$. Thanks to the ceiling, both functions overlap for integer arguments in the range from \$0\$ to \$22\$:
[![](https://i.stack.imgur.com/cy8Uc.png)source](http://www.wolframalpha.com/input/?i=Plot%5B%7Bn+Ceiling%5BLog_10%5B1+%2B+3%5En%5D%5D,+n+Ceiling%5Bn%2F2%5D%7D,+%7Bn,+0,+25%7D%5D)
[Answer]
# JavaScript (ES6), 12 bytes ([Cracked](https://codegolf.stackexchange.com/a/167656/58563))
This one is rather easy.
```
n=>n*(8*n+1)
```
[Try it online!](https://tio.run/##FcpBCoMwEEbhvaf4yWrGQWldCTbeJVhTFJkpKm5Kzx6T1ePBt4YrHNO@fM9G7T2n6JP6UWvqa5Unp2g7KTweAxQvdKUijF8FTKaHbXO72YdcIAfJRuA4@zKRlHmo/ukG "JavaScript (Node.js) – Try It Online")
This is [A139275](https://oeis.org/A139275):
$$a(n) = n(8n+1)$$
Your code must support \$0\le n<9\$:
$$0, 9, 34, 75, 132, 205, 294, 399, 520$$
And as per the challenge rules, it must diverge beyond.
[Answer]
# Malbolge, 10 bytes
```
ub&;$9]J6
```
Note that the code ends with an 0x14 (device control 4) byte.
[Try it online!](https://tio.run/##y03MScrPSU/9/780Sc1axTLWy0zk/39DAwA)
The 0-indexed sequence to crack is `[9, 19, 29]`.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 276 bytes ([Cracked](https://codegolf.stackexchange.com/a/167677/76162))
```
1$1-:?!v$:      1[0$          >:?!va2[$:{:@%:{$-{,]v
       >$n; v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<
```
[Try it online!](https://tio.run/##VY7BasQwDETv@QolqNCu62B7l0LVrK3/CA7kkm0hlJKCL8b5ddfe7RY6BzHiadAsH9/vOWvUklwbkOAqPSqEP9mKZjMiReIHiijjsw/NneLnGwT4pwFgqmiPXpleCy2WZRN6GxqgNG4@AoxKW4oHZoHzYTVn1067L2fiVehLd@zOLpR5278W1V@Tq9ISbf2ApB5dQEZiJn5ygbmgdOthO3NPqpK0/W@tSeoVQutSLdif5oTMWGz1QzOZl@g3NSaKfo9DzlkGOJ5@AA "><> – Try It Online") Call this one with `-v n` to get the n-th element (1-indexed)
```
1$1-:?!;$::n84*o1[0$          >:?!va2[$:{:@%:{$-{,]v
            v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<
```
[Try it online!](https://tio.run/##VY7BSsUwEEX3/YppGUEbU5K8Ijr2JfMfJYVuqkJRqZBNSH89pj4VvYvhDncOc5eXj@ecNWpJrn5Eotf7vn3To0L4lS1RmM2IFImvKKKMtz5U8EcB/mkAmA5wj16ZTgstlmUTehsqoDRuPgKMSluKLbPAuV3N2dXT7suZeBD6qTk1ZxfKvOzvi@q@yFVpifb4gKSuXUBGYia@cYG5ROnSwzbmh1SFtN13rUnqFULt0lGw6@eEzFjs4YdqMnfRb2pMFP0eh5yzDHDqPwE "><> – Try It Online") Call with `-v n` to get a list of n-1 elements starting at 1
[Online Fish Interpreter](https://fishlanguage.com/)
A long and complex one, this is [OEIS A004000](http://oeis.org/A004000).
> 
> Let a(n) = k, form m by Reversing the digits of k, Add m to k Then
>  Sort the digits of the sum into increasing order to get a(n+1).
> 
> 
> Example: 668 -> 668 + 866 = 1534 -> 1345.
> 
> 
> 
Because the code in ><> is quite long, the challenge is to crack it for \$n = 34\$.
These 34 elements make a total of 290 bytes, just a bit too much to hardcode the result ;)  
Here are the 34 first elements 1-indexed
```
1 2 4 8 16 77 145 668 1345 6677 13444 55778 133345 666677 1333444 5567777 12333445 66666677 133333444 556667777 1233334444 5566667777 12333334444 55666667777 123333334444 556666667777 1233333334444 5566666667777 12333333334444 55666666667777 123333333334444 556666666667777 1233333333334444 5566666666667777
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page), Safe!
```
<4+ạ2ȯ
```
This defines a **zero-indexed** sequence where:
$$ a(n) =
\begin{cases}
1 & n<3 \\
2 & n=3 \\
n-2 & n>3
\end{cases}$$
As such the first sixteen values \$a(0)\cdots a(15)\$ are `1,1,1,2,2,3,4,5,6,7,8,9,10,11,12,13`
**[Try it online!](https://tio.run/##y0rNyan8/9/GRPvhroVGJ9b/P9z@qGnN///RBjoKhjoKRjoKxjoKJjoKpjoKZjoK5joKFjoKlkApkDRQ3hCowBCowhCoxNA0FgA "Jelly – Try It Online")** ([here](https://tio.run/##y0rNyan8/9/GRPvhroVGJ9b////f0BQA) is a single value version)
This is not currently in the OEIS (although [A34138](https://oeis.org/A034138 "Number of partitions of n into distinct parts from [1,8]") will work as a crack if short enough)
### Intended Crack
> 
>  The sequence above agrees with the count of decimal digits of the first \$16\$ terms of [A062569](https://oeis.org/A062569 "a(n) = sigma(n!)"), the sum of the divisors of the factorial of \$n\$ (also zero-indexed).  
> 
>  The \$17^{\text{th}}\$ term of [A062569](https://oeis.org/A062569 "a(n) = sigma(n!)"), however, is \$107004539285280\$ which has \$15\$ digits, not \$14=a(16)\$.  
> 
>   
> 
>  The required code is **five** bytes in Jelly, [`!ÆsDL`](https://tio.run/##y0rNyan8/1/xcFuxi89/GxPth7sWGp1Yz3W4XefwRE33//@jDXQUDHUUjHQUjHUUTHQUTHUUzHQUzHUULHQULIFSIGmgvCFQgSFQhSFQiSFQjaFZLAA "Jelly – Try It Online").
> 
> 
> 
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~17~~ 15 [bytes](https://github.com/abrudz/SBCS), safe
```
⌈∊∘1 5+.633*5-⊢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P/1R24RHPR2POroedcwwVDDV1jMzNtYy1X3UtQgoeWjFo97NhsYA "APL (Dyalog Unicode) – Try It Online")
The first 13 terms (1-based) are:
```
2 1 1 1 2 2 3 4 7 10 16 25 39
```
Hint: The intended solution uses one of the least used built-in functions.
---
The intended code is the following:
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 10 [bytes](https://github.com/abrudz/SBCS)
```
⌊(2*⍳)⌹⌽∘⍳
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P/1R24RHPV0aRlqPejdrPurZ@ahn76OOGUAOUO7QCiBtaAwA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# JavaScript, 26 bytes ([Cracked](https://codegolf.stackexchange.com/a/167609/64505))
```
let f=x=>x>1?f(x-1)*f(x-2)+1:1
for (x of [0,1,2,3,4,5,6,7]) {
  console.log(x + ' -> ' + f(x))
}
```
[OEIS A007660](https://oeis.org/A007660)
Output is the first 6 elements with 0 indexing (1,1,2,3,7,22)
(somewhat shifted from what OEIS has it listed as)
Just creating a simple to solve answer to kick things off
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zbbC1q7CztA@TaNC11BTC0QZaWobWhn@L8ktsI020DHUMdIx1jHRMY3lSs7PK87PSdXLyU/XAMrq5SYWaKRpav4HAA "JavaScript (Node.js) – Try It Online")
[Answer]
# JavaScript, 16 bytes ([Cracked](https://codegolf.stackexchange.com/a/167623/64505))
```
g=
x=>Math.exp(x)|0
tmp=[0,1,2,3,4]
console.log(tmp.map(g).join(','))
```
First 5 elements of [OEIS149](https://oeis.org/A000149) (\$\lfloor e^n\rfloor\$)
Required inputs to match are 0,1,2,3,4.
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/C1s43sSRDL7WiQKNCs8bgf0lugW20gY6hjpGOsY6JjmksV3J@XnF@TqpeTn66BlBWLzexQCNNU/M/AA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes ([cracked](https://codegolf.stackexchange.com/a/167660/48198) by [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan?tab=profile))
This one is [A000030](https://oeis.org/A000030) shifted by \$16\$:
```
←d+16
```
[Try it online!](https://tio.run/##yygtzv7//1HbhBRtQ7P///8bAAA "Husk – Try It Online")
The sequence is 0-indexed, [output](https://tio.run/##yygtzv7/qG1ibn5xsM6jpsZzM/yA3Akp2oZm////NzIGAA "Husk – Try It Online") for \$ 0 \leq n < 23 \$:
$$ 1,1,1,1,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3 $$
### Explanation
```
←d+16  -- example input:  23
  +16  -- add 16:         39
 d     -- digits:         [3,9]
←      -- extract first:  3
```
### Solution
> 
>  [`LdΣ`](https://tio.run/##yygtzv7/3yfl3OL///8bAAA)
> 
> 
> 
[Answer]
# JavaScript, 25 bytes ([Cracked](https://codegolf.stackexchange.com/a/167666/64505) 21 bytes)
```
f=
x=>[7,11,12,13,13][x]||14
for(i=0;i<15;i++)
  console.log(i+"->"+f(i))
```
Sequence of 7,11,12,13,13 followed by infinite 14s.
Intended solution 22 bytes:
> 
>  x=Math.atan(x+1)\*10|0
> 
> 
> 
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/C1i7aXMfQUMfQSMfQGIhioytia2oMTf6n5RdpZNoaWGfaGJpZZ2pra3Il5@cV5@ek6uXkp2tkKmgr6dopaadpZGpq/gcA "JavaScript (Node.js) – Try It Online")
[Answer]
# JavaScript, 22 bytes ([Cracked](https://codegolf.stackexchange.com/a/167627/64505))
```
f=
x=>(3-(5/63)**.5)**x|1
for(y=0;y<16;y++)
  console.log(y +"->"+f(y))
```
This is 0 indexed and accuracy is required up to an input of 15. It can not be found on OEIS
My solution 20 bytes
> 
> x=>163\*\*(32\*x/163)|1
> 
> 
> 
[Try it online!](https://tio.run/##DcuxDoIwFEbh3cdguiU/xUtpkaG@iHFoEAwE2kaIYfDda5czfMlZ3Nftw2eOR@XDa0yTTae9k6pI10aJspQ65/xxOrZoH1cwGii00DDocEMPzsjgBqzALViDzfMyBL@HdZRreFNe5eYiTUIuYfZUoBAi/QE "JavaScript (Node.js) – Try It Online")
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 42 bytes, [cracked](https://codegolf.stackexchange.com/questions/167597/hardcoding-the-cops-and-robbers-robbers/167923#167923)
```
i3%0v
642 .
840
789
159
a 1
v<<
n
l
?
\/
;
```
[Try it online!](https://tio.run/##S8sszvj/P9NY1aCMy8zESEGPy8LEgMvcwpLL0NSSK1HBkKvMxoYrjyuHy54rRp/L@v9/AwA "><> – Try It Online")
Sequence to crack (0-indexed): `101786, 5844, 19902` (not on OEIS).
[Intended solution](https://tio.run/##S8sszvj/X9/eSkshL8aayy5H2ypJVZ8rk0uJy@D/fwMA), for reference.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 53 bytes
```
{(1,2,2,{$!=++$;prepend(@,2-$!%2 xx$_).pop}...*)[$_]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/WsNQxwgIq1UUbbW1VawLilILUvNSNBx0jHRVFFWNFCoqVOI19QryC2r19PS0NKNV4mNr/xeUlgC1a8QZGhtoWv8HAA "Perl 6 – Try It Online")
Anonymous code-block that returns the 0-indexed Kolakoski sequence ([OEIS A000002](http://oeis.org/A000002)). Solutions are required to match the first 130 elements, so that for some `n > 129` it differs from the Kolakoski sequence.
[Answer]
# [Pascal (FPC)](https://www.freepascal.org/), 86 bytes ([cracked](https://codegolf.stackexchange.com/a/170843))
```
var n:word;begin read(n);write(n div 2+n div 4+n div 8+n div 16+n div 32+n div 64)end.
```
[Try it online!](https://tio.run/##K0gsTk7M0U0rSP7/vyyxSCHPqjy/KMU6KTU9M0@hKDUxRSNP07q8KLMkVSNPISWzTMFIG0KbQGkLKG1oBmUYw1SYmWim5qXo/f9vCAA "Pascal (FPC) – Try It Online")
The sequence must be equal up to \$n=120\$. The sequence from input 0 to input 120 is
```
0   0   1   1   3   3   4   4   7   7   8   8  10  10  11  11  15  15  16  16  18  18  19  19  22  22  23  23  25  25  26  26  31  31  32  32  34  34  35  35  38  38  39  39  41  41  42  42  46  46  47  47  49  49  50  50  53  53  54  54  56  56  57  57  63  63  64  64  66  66  67  67  70  70  71  71  73  73  74  74  78  78  79  79  81  81  82  82  85  85  86  86  88  88  89  89  94  94  95  95  97  97  98  98 101 101 102 102 104 104 105 105 109 109 110 110 112 112 113 113 116
```
---
My original solution was
> 
> `var n,i,s:word;begin read(n);i:=2;repeat s:=s+n div i;i:=i*2until i>n;write(s)end.`
> 
> 
> 
but r\_64 [made it even better](https://codegolf.stackexchange.com/a/170843)!
]