**Multiplying over the comma**

Hello Seqfans,

Here is how we’ll
build **S**:

(a) start
with a(1)=1:

**S** = 1, ...

(b) to
compute a(n+1), start by calling “d” the last digit of a(n-1); we have here:

d = 1

(c) call
“i” the smallest integer which hasn’t yet multiplied “d”; we have here:

i = 1

(d) call
**P** the product < d.i >; we have
here:

**P** = d.i = 1.1 = 1

(e) let a(n+1) be
the concatenation < i_P >; we have here:

a(n+1) = < i_P
> = < 1_1 > = 11

Thus
**S** goes now:

**S** = 1, 11, ...

(f) goto (b):

We have for the next
term a(3):

d = 1 (the last digit of 11);

i = 2 [because “i” must be
the smallest integer which hasn’t yet multiplied the digit “1” (the integer 1
was used before)];

**P** = d.i = 1.2 = 2

a(3) = i_P = 22

**S** = 1, 11, 22, ...

Again, goto (b):

We have for the next
term a(4):

d = 2 (the last digit of the
last term, 22);

i = 1 [because “i” must be
the smallest integer which hasn’t yet multiplied the digit “2”];

**P** = d.i = 2.1 = 2

a(4) = i_P = 12

**S** = 1, 11, 22, 12, ...

Again, goto (b):

We have for the next
term a(5):

d = 2 (the last digit of the
last term, 12);

i = 2 [because “i” must be
the smallest integer which hasn’t yet multiplied the digit “2”];

**P** = d.i = 2.2 = 4

a(5) = i_P = 24

**S** = 1, 11, 22, 12, 24, ...

Again, goto (b):

We have for the next
term a(6):

d = 4 (the last digit of the
last term, 24);

i = 1 [because “i” must be
the smallest integer which hasn’t yet multiplied the digit “4”];

**P** = d.i = 4.1 = 4

a(6) = i_P = 14

**S** = 1, 11, 22, 12, 24, 14, ...

Again, goto (b):

We have for the next
term a(7):

d = 4 (the last digit of the
last term, 14);

i = 2 [because “i” must be
the smallest integer which hasn’t yet multiplied the digit “4”];

**P** = d.i = 4.2 = 8

a(7) = i_P = 28

**S** = 1, 11, 22, 12, 24, 14, 28, ...

Again, goto (b):

We have for the next
term a(8):

d = 8 (the last digit of the
last term, 28);

i = 1 [because “i” must be
the smallest integer which hasn’t yet multiplied the digit “8”];

**P** = d.i = 8.1 = 8

a(8) = i_P = 18

**S** = 1, 11, 22, 12, 24, 14, 28, 18, ...

Again, goto (b):

We have for the next
term a(9):

d = 8 (the last digit of the
last term, 18);

i = 2 [because “i” must be
the smallest integer which hasn’t yet multiplied the digit “8”];

**P** = d.i = 8.2 = 16

a(9) = i_P = 216

**S** = 1, 11, 22, 12, 24, 14, 28, 18, 216, ...

Again, goto (b):

We have for the next
term a(10):

d = 6 (the last digit of the
last term, 216);

i = 1 [because “i” must be
the smallest integer which hasn’t yet multiplied the digit “6”];

**P** = d.i = 6.1 = 6

a(10) = i_P = 16

**S** = 1, 11, 22, 12, 24, 14, 28, 18, 216, 16, ...

We see that S goes
smoothly like this:

**S** = 1, 11, 22, 12, 24, 14, 28, 18, 216, 16, 212, 48, 324, 312, 510.

... but here we have to introduce a new rule – else will stop
(because of zero, the last digit of 510):

(e2) “i”
has to be discarded if the product d.i ends with
zero; try the next smallest “i” (and never come back to the “bad” “i”).

We see at the end
here... that the 0 comes from the 5;

**S** = 1, 11, 22, 12, 24, 14, 28, 18, 216, 16, 212, 48, 324, 312, 510.

... if we replace 5
by 6 (the next “i”), everything will be fixed:

**S** = 1, 11, 22, 12, 24, 14, 28, 18, 216, 16, 212, 48, 324, 312, 612, ...

All terms of S will
be different, by construction – and S is quite fun to watch: multiplying two
terms is like considering that the comma < , > __is__
the multiplying sign < x >. The full operation (multiplication and
result) is under the very eyes of the reader – and only that, no parasite
characters!

If this is of
interest, this could be extended quite easily and submitted to the OEIS:

**S** = 1,11,22,12,24,14,28,18,216,16,212,36,318,324,312,48,432,612,714,416,424,624,728,...

1,11,22,12,24,14,28,18,216,16,212,48,324,312,612,714,416,318,432, ...

Best,

É.

__________

Breaking news:

**Maximilian Hasler** has corrected and extended the sequence **S** here.

Many thanks!

Best,

É.