import numpy as np


def generate_answer(n: int, low_limit:int, high_limit: int):
    while True:
        a = np.random.randint(low_limit, high_limit + 1, 1)[0]
        b = np.random.randint(low_limit, high_limit + 1, 1)[0]
        c = (n - 7 * a - 5 * b) / 3.0
        if int(c) == c and low_limit <= c <= high_limit:
            break

    return a, b, int(c)


if __name__ == "__main__":
    n = 30
    ans = generate_answer(low_limit=-5, high_limit=50, n=n)
    assert ans[0] * 7 + ans[1] * 5 + ans[2] * 3 == n
    print(ans)

If you select two of the numbers a, b, c, you know the third. In this case, I randomize ints for a, b, and I find c by c = (n - 7 * a - 5 * b) / 3.0.

Make sure c is an integer, and in the allowed limits, and we are done.

If it is not, randomize again.

If you want to generate all possibilities,

def generate_all_answers(n: int, low_limit:int, high_limit: int):
    results = []
    for a in range(low_limit, high_limit + 1):
        for b in range(low_limit, high_limit + 1):
            c = (n - 7 * a - 5 * b) / 3.0
            if int(c) == c and low_limit <= c <= high_limit:
                results.append((a, b, int(c)))

    return results

If third-party libraries are allowed, you can use SymPy's diophantine.diop_linear linear Diophantine equations solver:

from sympy.solvers.diophantine.diophantine import diop_linear
from sympy import symbols
from numpy.random import randint

n = 30
N = 8 # Number of solutions needed

# Unknowns
a, b, c = symbols('a, b, c', integer=True)

# Coefficients
x, y, z = 7, 5, 3

# Parameters of parametric equation of solution
t_0, t_1 = symbols('t_0, t_1', integer=True)

solution = diop_linear(x * a + y * b + z * c - n)

if not (None in solution):
  for s in range(N):
    # -10000 and 10000 (max and min for t_0 and t_1)
    t_sub = [(t_0, randint(-10000, 10000)), (t_1, randint(-10000, 10000))]

    a_val, b_val, c_val = map(lambda t : t.subs(t_sub), solution)

    print('Solution #%d' % (s + 1))
    print('a =', a_val, ', b =', b_val, ', c =', c_val)
else:
  print('no solutions')

Output (random):

Solution #1
a = -141 , b = -29187 , c = 48984
Solution #2
a = -8532 , b = -68757 , c = 134513
Solution #3
a = 5034 , b = 30729 , c = -62951
Solution #4
a = 7107 , b = 76638 , c = -144303
Solution #5
a = 4587 , b = 23721 , c = -50228
Solution #6
a = -9294 , b = -106269 , c = 198811
Solution #7
a = -1572 , b = -43224 , c = 75718
Solution #8
a = 4956 , b = 68097 , c = -125049

Why your solution can't cope with large values of n

You may understand that everything in a for loop with a range of i, will run i times. So it will multiply the time taken by i.

For example, let's pretend (to keep things simple) that this runs in 4 milliseconds:

if 7*a + 5*b + 3*c = n:
    c.append(a)
    k.append(b)
    w.append(c)

then this will run in 4×n milliseconds:

for c in range(n):
    if 7*a + 5*b + 3*c = n:
        c.append(a)
        k.append(b)
        w.append(c)

Approximately:

• n = 100 would take 0.4 seconds
• n = 250 would take 1 second
• n = 15000 would take 60 seconds

If you put that inside a for loop over a range of n then the whole thing will be repeated n times. I.e.

for b in range(n):
    for c in range(n):
        if 7*a + 5*b + 3*c = n:
            c.append(a)
            k.append(b)
            w.append(c)

will take 4n² milliseconds.

• n = 30 would take 4 seconds
• n = 50 would take 10 seconds
• n = 120 would take 60 seconds

Putting it in a third for-loop will take 4n³ milliseconds.

• n = 10 would take 4 seconds
• n = 14 would take 10 seconds.
• n = 24 would take 60 seconds.

Now, what if you halved the original if to 2 milliseconds? n would be able to increase by 15000 in the first case... and 23 in the last case. The lesson here is that fewer for-loops is usually much more important than speeding up what's inside them. As you can see in Gulzar's answer part 2, there are only two for loops which makes a big difference. (This only applies if the loops are inside each other; if they are just one after another you don't have the multiplication problem.)

from my perspective, the last number of the three is never a random number. let say you generate a and b first then c is never a random because it should be calculated from the equation

n = 7*a + 5*b + 3*c
c = (7*a + 5*b - n) / -3

this means that we need to generate two random values (a,b) that 7*a + 5*b - n is divisible by 3

import random

n = 30;
max = 1000000;
min = -1000000;

while True:
  a = random.randint(min , max);
  b = random.randint(min , max);
  t = (7*a) + (5*b) - n;
  if (t % 3 == 0) :
    break;

c = (t/-3);

print("A = " + str(a));
print("B = " + str(b));
print("C = " + str(c));
print("7A + 5B + 3C =>")
print("(7 * " + str(a) + ") + (5 * " + str(b) + ") + (3 * " + str(c) + ") = ")
print((7*a) + (5*b) + (3*c));

REPL