Print greatest factor if it is same for both numbers

Question

Take input n1 and n2 and check if they have the same greatest factor. If they do, print that factor. If they don't, print "No".

example:
input:
6
9
output:
3

input:
15
27
output:
No

n1=int(input())
n2=int(input())
l1=[]
l2=[]
for i in range(1,n1):
    if n1%i==0:
        l1.append(i)
        l1.sort(reverse=True)
cf1=l1[0]
for j in range(1,n2):
    if n2%j==0:
        l2.append(j)
        l2.sort(reverse=True)
cf2=l2[0]
if cf1==cf2:
    print(cf1)
else:
    print("No")

Answer 1

At any point, 1 is always common factor of any two numbers. Your code works perfectly. But if you want to write a shorter code, check the condition if both numbers are divisible by any number using for loop going from range 2 (1 is always factor) to min of both numbers. Take a new variable f which is False initially. If the condition is satisfied i.e. if both nos are divisible by a no, change f to True. Then, out of the loop, write an if condition, if f==True then print the number or else the condition was never satisfied and f is False and print "no". Your code:

n1=int(input("Enter n1"))
n2=int(input("Enter n2"))
f=False
for i in range(2,min([n1,n2])):
    if n1%i==0 and n2%i==0:
        g=i
        f=True
if f:
    print(g)
else:
    print("no")

Answer 2

Quick and easy changes:

• input should prompt what it's asking for.
• You want to encapsulate what you're doing into a function, but the function should just return, not print. But it's strange for a function to sometimes return a string and sometimes a number, so I've made it only return a number, and saved switching to "No" for the main thread to decide.
• You should document what you're doing and why. Since there's been some confusion about the greatest common factor, you should definitely document that this isn't that. Type hints are also nice. I've also included some doctest entries, so that you could run python -m doctest -v myscript.py and double check that it's working.
• Use an if __name__ == '__main__' guard
• The only point of l1 is to get the first number. We can skip the reversing and just get the last number: cf1=l1[-1].

A much better change comes from realizing that factors come in pairs (with a square root paired with itself). This means that the greatest factor pairs with the least factor greater than 1:
cf1 = n1/next( n for n in range(2,n1+1) if n1%n==0 )
We could do the same thing for cf2, which would make the function symmetric and easier to understand. But if we're desperate for that last performance boost, we can do a bit better:

If they have a common greatest factor, then it will be the greatest common factor. The Euclidean algorithm will very quickly find this value. The only thing that could mess things up would be if there is some other factor between cf and n. That could be a lot of numbers to check, but we can do the pairing trick again, and look for other numbers between 1 and n/cf. If there's a factor there, then there is a greater factor than the greatest common factor, and they don't have a common greatest factor.

def commonGreatestFactor(n1:int,n2:int) -> int:
    '''
    Finds if the greatest factor of each number is the same, and returns it.
    This is not the greatest common factor
    (although if they have the same greatest factor, then it is equal to the gcf).
    If they do not share the same greatest factor, this returns 0.
    
    >>> commonGreatestFactor(3,6)
    0
    >>> commonGreatestFactor(6,9)
    3
    >>> commonGreatestFactor(12,18)
    0
    >>> commonGreatestFactor(15,27)
    0
    '''
    gcf,other = n1,n2
    while other:
        gcf,other = other,gcf%other
    if min(n1,n2)==gcf<max(n1,n2):
        return 0
    # if there's a factor of n1 between 1 and n1/gcf,
    # then the gcf is not the greatest factor of n1
    if next( (n for n in range(2,n1//gcf) if n1%n==0) , 0 ):
        return 0
    if next( (n for n in range(2,n2//gcf) if n2%n==0) , 0 ):
        return 0
    return gcf

if __name__ == '__main__':
    n1=int(input('First number: '))
    n2=int(input('Second number: '))
    result = commonGreatestFactor(n1,n2)
    if result:
        print(result)
    else:
        print("No")

Answer 3

"The sort()s" would work just fine called once each - after the loops.
Instead of l1.sort(reverse=True), you could just use l1 = list(reversed([1, 2])). Or omit permuting the lists and just pick the highest factor:
factor1 = l1[-1]
(Building the lists using
l1.insert(0, trial_divisor) followed by factor1 = l1[0] is worse.)

But when wanting greatest factors, only, why accumulate complete lists?

def greatest_factor(n):
    """ Given a natural number n, return its greatest factor below n."""
    if n % 2 == 0:
        return n // 2
    for trial_divisor in range(3, int(math.sqrt(n)) + 1, 2):
        if n % trial_divisor == 0:
            return n // trial_divisor
    return 1

(Consider defining smallest_factor() (exceeding 1) and using that for greatest_factor().)

(For a sane way to check for a common greatest factor as defined in the problem statement, Teepeemm's answer's first revision just needs a bit of tying up loose ends.)