A087062 Array T(n,k) = lunar product n*k (n >= 1, k >= 1) read by antidiagonals.

1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 2, 3, 2, 1, 1, 2, 3, 3, 2, 1, 1, 2, 3, 4, 3, 2, 1, 1, 2, 3, 4, 4, 3, 2, 1, 1, 2, 3, 4, 5, 4, 3, 2, 1, 10, 2, 3, 4, 5, 5, 4, 3, 2, 10, 11, 10, 3, 4, 5, 6, 5, 4, 3, 10, 11, 11, 11, 10, 4, 5, 6, 6, 5, 4, 10, 11, 11, 11, 12, 11, 10, 5, 6, 7, 6, 5, 10, 11, 12, 11, 11, 12, 12

Offset

1,5

Comments

See A087061 for definition. Note that 0+x = x and 9*x = x for all x.

This differs from A003983 at a(46): min(1,10)=1, while lunar product 10*1 = 10.

We have now changed the name from "dismal arithmetic" to "lunar arithmetic" - the old name was too depressing. - N. J. A. Sloane, Aug 06 2014

Links

Alois P. Heinz, Table of n, a(n) for n = 1..10011

D. Applegate, C program for lunar arithmetic and number theory

D. Applegate, M. LeBrun and N. J. A. Sloane, Dismal Arithmetic, arXiv:1107.1130 [math.NT], 2011.

Brady Haran and N. J. A. Sloane, Primes on the Moon (Lunar Arithmetic), Numberphile video, Nov 2018.

Index entries for sequences related to dismal (or lunar) arithmetic

Example

Lunar multiplication table begins:
1 1 1 1 1 ...
1 2 2 2 2 ...
1 2 3 3 3 ...
1 2 3 4 4 ...
1 2 3 4 5 ...

Maple

# convert decimal to string: rec := proc(n) local t0, t1, e, l; if n <= 0 then RETURN([[0], 1]); fi; t0 := n mod 10; t1 := (n-t0)/10; e := [t0]; l := 1; while t1 <> 0 do t0 := t1 mod 10; t1 := (t1-t0)/10; l := l+1; e := [op(e), t0]; od; RETURN([e, l]); end;
# convert string to decimal: cer := proc(ep) local i, e, l, t1; e := ep[1]; l := ep[2]; t1 := 0; if l <= 0 then RETURN(t1); fi; for i from 1 to l do t1 := t1+10^(i-1)*e[i]; od; RETURN(t1); end;
# lunar addition: dadd := proc(m, n) local i, r1, r2, e1, e2, l1, l2, l, l3, t0; r1 := rec(m); r2 := rec(n); e1 := r1[1]; e2 := r2[1]; l1 := r1[2]; l2 := r2[2]; l := max(l1, l2); l3 := min(l1, l2); t0 := array(1..l); for i from 1 to l3 do t0[i] := max(e1[i], e2[i]); od; if l>l3 then for i from l3+1 to l do if l1>l2 then t0[i] := e1[i]; else t0[i] := e2[i]; fi; od; fi; cer([t0, l]); end;
# lunar multiplication: dmul := proc(m, n) local k, i, j, r1, r2, e1, e2, l1, l2, l, t0; r1 := rec(m); r2 := rec(n); e1 := r1[1]; e2 := r2[1]; l1 := r1[2]; l2 := r2[2]; l := l1+l2-1; t0 := array(1..l); for i from 1 to l do t0[i] := 0; od; for i from 1 to l2 do for j from 1 to l1 do k := min(e2[i], e1[j]); t0[i+j-1] := max(t0[i+j-1], k); od; od; cer([t0, l]); end;

Mathematica

ladd[x_, y_] := FromDigits[MapThread[Max, IntegerDigits[#, 10, Max@IntegerLength[{x, y}]] & /@ {x, y}]];
lmult[x_, y_] := Fold[ladd, 0, Table[10^i, {i, IntegerLength[y] - 1, 0, -1}]*FromDigits /@ Transpose@Partition[Min[##] & @@@ Tuples[IntegerDigits[{x, y}]], IntegerLength[y]]];
Flatten[Table[lmult[k, n - k + 1], {n, 1, 13}, {k, 1, n}]] (* Davin Park, Oct 06 2016 *)

Prog

(Python)
def lunar_add(n, m):
    sn, sm = str(n), str(m)
    l = max(len(sn), len(sm))
    return int(''.join(max(i, j) for i, j in zip(sn.rjust(l, '0'), sm.rjust(l, '0'))))
def lunar_mul(n, m):
    sn, sm, y = str(n), str(m), 0
    for i in range(len(sm)):
        c = sm[-i-1]
        y = lunar_add(y, int(''.join(min(j, c) for j in sn))*10**i)
    return y # Chai Wah Wu, Sep 06 2015
(PARI) lmul=A087062(m, n, d(n)=Vecrev(digits(n)))={sum(i=1, #(n=d(n))-1+#m=d(m), vecmax(vector(min(i, #n), j, if(#m>i-j, min(n[j], m[i-j+1]))))*10^i)\10} \\ M. F. Hasler, Nov 13 2017

Crossrefs

Cf. A087061 (addition), A003983 (min), A087097 (lunar primes).

See A261684 for a version that includes the zero row and column.

Sequence in context: A356300 A348041 A003983 * A204026 A300119 A323211

Adjacent sequences: A087059 A087060 A087061 * A087063 A087064 A087065

Keyword

nonn,tabl,nice,base,look

Author

Marc LeBrun, Oct 09 2003

Extensions

Maple programs from N. J. A. Sloane.

Incorrect comment and Mathematica program removed by David Applegate, Jan 03 2012

Edited by M. F. Hasler, Nov 13 2017

Status

approved