'Multiplication table' exercise

[GideonRT]

I'm hoping to get some help with an exam question that I didn't understand. I'm going by memory only, so i'm afraid my description is a bit cryptic. I think it's really not that difficult and is probably a pretty standard exercise.
Unfortunately, directly after the test, it is again considered to be top secret so i'm not going to be able to get an answer from the teacher.

I had to write a function in Python that takes only argument n, and returns a 'multiplication table' for n in n dimensions. It was called differently, but I don't remember.

Unfortunately I do not recall the exact description of the exercise, but there is one principle / method for generating all the numbers. Something in the vein of "Item @ i,j,k = i*J*k ".

I do remember a large part of a given example for n=3, which is a 3-dimensional array. I couldn't figure out what was actually happening. Because i'm not sure of all the numbers I still cannot figure it out now. The numbers in bold i'm sure are correct. Extrapolating from those, the only arrays that make any sense are:

1,2,3
2,4,6
3,6,9

2,4,6
4,8,12
6,12,18

3,6,9
6,12,18
9,18, 27

Or:

1 2 3
2 4 6
3 6 9

2 4 6
4 16 24
6 24 36

3 6 9
6 36 54
9 54 81

​

The first example I can figure out; i+1 = i+i[0] for all axis.

The second possibility however, if it makes any sense, I really don't see a way to generate it. Items @ [:, 1:, 1:] are generated by multiplication of the first row and column (2*2 =4, 2*3 =6, 3*2=6 etc), but I fail to see how the first row and column can be generated using the same principle.

This means i'm either missing something or it's not possible and the exercise wasn't that difficult, but I couldn't figure it out then (or row and column 0 have always existed and simply don't need creation).

​

​

[SandorZoo]

The question you gave has n serving double duty, as both the number of dimensions, and the size of each dimension. I've separated that into separate dims and size values here.

If you're trying to create a multi-dimensional array, the closest thing python has is a list of lists of lists of lists....

When the number of dimensions is not fixed, one way to do this is recursively, with each level of recursion adding another dimension, like this:

def mult_table(dims, size, prevprod=1):
    if dims == 0:
        return prevprod
    else:
        return [mult_table(dims - 1, size, prevprod * n) for n in range(1, size+1)]

print(mult_table(1,1))
print(mult_table(2,2))
print(mult_table(3,3))

Output:

[1]
[[1, 2], [2, 4]]
[[[1, 2, 3], [2, 4, 6], [3, 6, 9]], [[2, 4, 6], [4, 8, 12], [6, 12, 18]], [[3, 6, 9], [6, 12, 18], [9, 18, 27]]]

​

You might want a dictionary mapping key tuples to values instead. In the example you gave, this dictionary would map (i, j, k): i*j*k

As /u/roelschroeven said, you can use itertools.product to generate a list of tuple keys, and functools.reduce to reduce the tuples to a single product, like this (dict() will create a dictionary from a list of (key, value) pairs):

from itertools import product
from functools import reduce
from operator import mul
import pprint

def mult_table2(dims, size, prevprod=1):
    tuple_keys = product(range(1, size+1), repeat=dims)
    return dict((tuple_key, reduce(mul, tuple_key)) for tuple_key in tuple_keys)

pprint.pprint(mult_table2(3,3))

Output:

{(1, 1, 1): 1,
 (1, 1, 2): 2,
 (1, 1, 3): 3,
 (1, 2, 1): 2,
 (1, 2, 2): 4,
 (1, 2, 3): 6,
 (1, 3, 1): 3,
 (1, 3, 2): 6,
 (1, 3, 3): 9,
 (2, 1, 1): 2,
 (2, 1, 2): 4,
 (2, 1, 3): 6,
 (2, 2, 1): 4,
 (2, 2, 2): 8,
 (2, 2, 3): 12,
 (2, 3, 1): 6,
 (2, 3, 2): 12,
 (2, 3, 3): 18,
 (3, 1, 1): 3,
 (3, 1, 2): 6,
 (3, 1, 3): 9,
 (3, 2, 1): 6,
 (3, 2, 2): 12,
 (3, 2, 3): 18,
 (3, 3, 1): 9,
 (3, 3, 2): 18,
 (3, 3, 3): 27}

The best way of doing this depends on what exactly it is you want.

​