Example1:

sign = '-'

max = 2

2-2

2-1

1-1

- we have only three unique combinations.

Example2:

answer can't be upper max:

max = 2

1+1

- we have only one unique example.

I already have formula for two signs "+-": unic_col=max**2

But i need formula for '+' and '-'

And maybe someone know for:

+-×

+-/

+-×/

/×

So, i need function like that:

def uniques_col(operators, max):

if operators == '+-':

return max**2

elif operators == '+':

return .....

elif operators == '-':

return .....

elif operators == '+-×':

return .....

......

```
def uniques_col(operators, max):
col = 0
if len(operators) > 1:
for op in operators:
col += uniques_col(op, max)
return col
if operators == '+':
for i in range(1,max):
col += max - i
# comment next lines if you don't want detail
for j in range(1,max-i+1):
print(i,operators,j,i+j)
elif operators == '-':
for i in range(1,max+1):
col += i
# comment next lines if you don't want detail
for j in range(1,i+1):
print(i,operators,j,i-j)
elif operators == 'x':
for i in range(1,max+1):
col += int(max/i)
# comment next lines if you don't want detail
for j in range(1,1+int(max/i)):
print(i,operators,j,i*j)
return col
while True:
op = input('operator\n')
max = int(input('max\n'))
print(uniques_col(op,max))
```

]]>it looked so simple

Haha 😂

]]>@JonB, yes, we include 1-1 as per the ”rules”.

```
def unique_cols(ops, maximum):
counts = {
'-': lambda m: m*(m+1)//2,
'+': lambda m: m*(m-1)//2,
'/': lambda m: m**2,
'*': lambda m: sum([m//i for i in range(1, m+1)]),
}
return sum([counts[op](maximum) for op in ops])
maximum = int(input('Maximum integer: '))
ops = input('Operations (one or more of +-*/): ')
print('Unique combinations:', unique_cols(ops, maximum))
```

]]>```
for i in range(1,max+1):
col += int(max/i)
```

]]>I guess it depends on whether you allow 1-1=0 and the like. If so you'd add back N, and get N*(N+1)/2.

]]>```
from itertools import product
from math import floor, sqrt
def unique_cols(ops, maximum):
counts = {
'-': lambda m: m*(m+1)//2,
'+': lambda m: m*(m-1)//2,
'/': lambda m: m**2,
'*': lambda m:
2 * sum([(m//k)-k
for k in range(1, 1 + floor(sqrt(m)))]) +
floor(sqrt(m)),
}
return sum([counts[op](maximum) for op in ops])
maximum = int(input('Maximum integer: '))
ops = input('Operations (one of more of +-*/): ')
print('Unique combinations:', unique_cols(ops, maximum))
```

]]>For each row of the multiplication table, excluding the diagonal, you get

```
1*x (x!=1) ==> N-1 different possiblities
2*x (x!=2) ==> (N//2)-1
...
K*x (x!=K) ==> (N//k)-1
```

Then for the diagonal, it is the number of x**2<N

Or, x<=sqrt(N)

So the total is:

```
sum([(N//k) for k in range(1,N+1)])-N+floor(sqrt (N) )
Or
sum([(N//k) for k in range(2,N+1)])+floor(sqrt (N) )
```

Not quite brute force, but order N instead of N**2. You could also make use of the symmetry to only count through sqrt(N), which makes it order sqrt (N)..

`2*sum([(N//k)-k for k in range(1,1+floor(sqrt(N))])+floor(sqrt (N) )`

]]>`*`

seems to be directly related to finding the factors of an integer, for which there is no straight-forward formula (hence, public key cryptography works), so we still have to brute-force it.
```
from functools import reduce
from itertools import product
def unique_cols(ops, maximum):
counts = {
'-': lambda m: m*(m+1)//2,
'+': lambda m: m*(m-1)//2,
'/': lambda m: m**2,
'*': lambda m: len(list(filter(
lambda c: 0 <= eval(''.join(c)) <= m,
product([str(i+1) for i in range(m)], '*', [str(i+1) for i in range(m)])
)))
}
return sum([counts[op](maximum) for op in ops])
maximum = int(input('Maximum integer: '))
ops = input('Operations (one of more of +-*/): ')
print('Unique combinations:', unique_cols(ops, maximum))
```

]]>```
def uniques_col(operators, max):
col = 0
if len(operators) > 1:
for op in operators:
col += uniques_col(op, max)
return col
if operators == '+':
for i in range(1,max):
for j in range(1,max-i+1):
print(i,operators,j,i+j)
col += 1
elif operators == '-':
for i in range(1,max+1):
for j in range(1,i+1):
print(i,operators,j,i-j)
col += 1
elif operators == 'x':
for i in range(1,max+1):
for j in range(1,1+int(max/i)):
print(i,operators,j,i*j)
col += 1
return col
while True:
op = input('operator\n')
max = int(input('max\n'))
```

]]>```
from itertools import product
def uniques_col(ops, maximum):
numbers = [str(i+1) for i in range(maximum)]
return filter(
lambda c: 0 <= eval(''.join(c)) <= maximum,
product(numbers, ops, numbers)
)
ops_list = ['+-*', '+-/', '+-/*', '/*']
to_limit = 20
for ops in ops_list:
print('-'*20)
print('ops', ops)
for maximum in range(1, to_limit+1):
print(maximum, len(list(
uniques_col(ops, maximum))))
```

... gives series up to 20 for each set of operations. For `+-/`

, I can deduct that the formula for possibilities is `2*max*max`

. For the others, not as easy, need to dig out a maths book or two.

```
def uniques_col(operators, max):
col = 0
if operators == '+':
for i in range(1,max):
for j in range(1,max-i+1):
col += 1
elif operators == '-':
for i in range(1,max+1):
for j in range(1,i+1):
col += 1
elif operators == '+-':
col = max**2
return col
while True:
op = input('operator\n')
max = int(input('max\n'))
print(uniques_col(op,max))
```

```
And maybe you know uniques col for:
+-×
+-/
+-×/
/×
```

??? Thank's in advance!!!

]]>What’s new in Python 3

For clarity, What’s new in Python 3 does not advice against using `map`

and `filter`

as such, but against using `list(map(...))`

when a list comprehension can be used instead.

Thus, as already said, your amendment makes a lot of sense, but it does not automatically follow that we would change the filter into a comprehension, if we want to leave it up to the user of the function to decide whether to ”collapse” the iterator or not.

]]>I was debating the value of separating the range of numbers (problem domain issue) and the conversion to strings (a technical implementation detail).

]]>Read “What’s new in Python 3” for a discussion on avoiding map(), reduce(), filter().

]]>```
from itertools import product
def uniques_col(ops, maximum):
number_range = range(1, maximum+1)
numbers = list(map(str, number_range))
return filter(
lambda c: 0 <= eval(''.join(c)) <= maximum,
product(numbers, ops, numbers)
)
uniques = uniques_col('+-/', 2)
print(*[
f"{i+1:4}: {''.join(c)}"
for i, c in enumerate(uniques)],
sep='\n'
)
```

]]>With « my » formula, no check is needed ]]>

Or Change into

```
if operators == '+':
for i in range(1,max):
for j in range(1,max-i+1):
```

]]>