# Progressing Two's

## Python 2, 52 bytes

```
n=p=0
exec"n+=1;r=n-n**.5//1;print p+r;p=r;"*input()
```

Try it online!

**54 bytes**

```
lambda N:[n-~n-n**.5//1-(n+1)**.5//1for n in range(N)]
```

Try it online!

It's a formula!

$$f(n) = 2n+1 - \lfloor \sqrt n\rfloor - \lfloor \sqrt {n+1} \rfloor$$

This can also be split up as

$$f(n) = \sum_{k \in \{n,n+1\}}\left({k-\lfloor \sqrt k\rfloor}\right)$$

Note that \$k-\lfloor \sqrt k\rfloor\$ is the number of non-squares from \$1\$ to \$k\$ inclusive.

## APL (Dyalog Extended), ^{14} 12 bytes

```
0,2+/⍳-⌊∘√∘⍳
```

Try it online!

Uses xnor's formula of

$$ f(n) = \sum_{k \in \{n,n+1\}}\left({k-\lfloor \sqrt k\rfloor}\right) $$

### How it works

```
0,2+/⍳-⌊∘√∘⍳
⍳- ⍝ 1..n minus...
⌊∘√∘⍳ ⍝ floor(sqrt(1..n))
2+/ ⍝ Add two consecutive pairs
⍝ giving first n items of the sequence except leading 0
0, ⍝ Prepend the leading 0
```

## APL (Dyalog Extended), 14 bytes

```
⊢↑2(∧+/,2××/)⍳
```

Try it online!

Based on the observation that the sequence is the union of all odd numbers and the numbers in the form of \$2n(n+1), n \ge 0\$. Uses `⎕IO←0`

.

### How it works

```
⊢↑2(∧+/,2××/)⍳ ⍝ Input: positive integer n
⍳ ⍝ Generate 0..n-1
2( ×/) ⍝ Pairwise product (0×1, 1×2, ..., (n-2)×(n-1))
2× ⍝ Double it
+/, ⍝ Concat with pairwise sum (0+1, 1+2, ..., (n-2)+(n-1))
∧ ⍝ Ascending sort the 2(n-1) numbers in total
⊢↑ ⍝ Take the first n numbers
⍝ For n=1, "overtake" from zero elements, giving single 0
```

## Haskell, 42 bytes

```
(`take`q 4)
q k=0:[1,3..k]++map(k+)(q$k+4)
```

Try it online!

Uses a version of Bubbler's observation that the sequence alternates runs of consecutive odd numbers with an even number directly in between.

## Haskell, 43 bytes

```
(`take`scanl(+)0(q[2]))
q r=1:r++1:q(2:2:r)
```

Try it online!

Generates an infinite list of 1's and 2's, take the cumulative sums, and truncates to the input length.