Python Program for Find sum of odd factors of a number

In this article, we will learn how to find the sum of odd factors of a number. We need to identify all factors that are odd and calculate their sum.

Problem Statement

Given a number n, find the sum of all its odd factors. For example, if n = 12, the factors are [1, 2, 3, 4, 6, 12], and the odd factors are [1, 3], so the sum is 4.

Approach

To find odd factors efficiently, we first eliminate all even factors by dividing the number by 2 repeatedly. Then we find all remaining odd prime factors and calculate the sum using the formula for sum of divisors.

Implementation

import math

def sum_of_odd_factors(n):
    """
    Find sum of all odd factors of a number
    """
    result = 1
    
    # Remove all even factors by dividing by 2
    while n % 2 == 0:
        n = n // 2
    
    # Process odd factors from 3 onwards
    for i in range(3, int(math.sqrt(n)) + 1, 2):
        current_sum = 1
        current_term = 1
        
        # If i is a factor, calculate sum of powers
        while n % i == 0:
            current_term *= i
            current_sum += current_term
            n = n // i
        
        result *= current_sum
    
    # If n is still greater than 1, it's a prime factor
    if n > 1:
        result *= (1 + n)
    
    return result

# Example usage
numbers = [12, 27, 30]

for num in numbers:
    odd_sum = sum_of_odd_factors(num)
    print(f"Sum of odd factors of {num}: {odd_sum}")

Sum of odd factors of 12: 4
Sum of odd factors of 27: 40
Sum of odd factors of 30: 24

How It Works

The algorithm works in three steps:

Step 1: Remove all factors of 2 by repeatedly dividing n by 2 until it's no longer divisible.

Step 2: For each odd number from 3 to ?n, if it divides n, calculate the sum of all its powers that divide n using the formula: 1 + p + p² + ... + p^k.

Step 3: If n is still greater than 1 after processing, it's a prime factor, so add (1 + n) to the result.

Manual Verification

Let's verify for n = 12:

def find_all_factors(n):
    """Helper function to find all factors"""
    factors = []
    for i in range(1, n + 1):
        if n % i == 0:
            factors.append(i)
    return factors

def find_odd_factors(n):
    """Find only odd factors"""
    factors = find_all_factors(n)
    odd_factors = [f for f in factors if f % 2 == 1]
    return odd_factors

# Verify for n = 12
n = 12
all_factors = find_all_factors(n)
odd_factors = find_odd_factors(n)
manual_sum = sum(odd_factors)
algorithmic_sum = sum_of_odd_factors(n)

print(f"Number: {n}")
print(f"All factors: {all_factors}")
print(f"Odd factors: {odd_factors}")
print(f"Manual sum: {manual_sum}")
print(f"Algorithm result: {algorithmic_sum}")
print(f"Match: {manual_sum == algorithmic_sum}")

Number: 12
All factors: [1, 2, 3, 4, 6, 12]
Odd factors: [1, 3]
Manual sum: 4
Algorithm result: 4
Match: True

Conclusion

The algorithm efficiently finds the sum of odd factors by first eliminating all even factors, then processing odd prime factors using mathematical formulas. This approach is much faster than checking all possible factors individually.