Multiplying over the comma

 

Hello Seqfans,

 

Here is how well 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 hasnt 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 hasnt 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 hasnt 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 hasnt 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 hasnt 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 hasnt 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 hasnt 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 hasnt 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 hasnt 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,

.