Open In App

Find all the factors of given Number and their bitwise XOR

Last Updated : 14 Nov, 2022
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given an integer N, the task is to find all the factors (excluding itself) of the number N and their XOR.

Examples:

Input: N = 8 
Output:
Divisors are: 1 2 4 
Xor: 7
Explanation:  1, 2 and 4 are all factors of 8 and 1^2^4 = 7.

Input: N = 25
Output:
Divisors are: 1 5 
Xor: 4

Approach: Follow the below idea to solve the problem:

Store all the factors of the given number N and calculate the xor of all the factors

Follow the steps to solve this problem:

  • Initialize a variable Xor = 0
  • Create vector factors1 and factors2 for storing factors from 1 to sqrt(N) and from sqrt(N) to N.
  • Traverse the array from 1 till sqrt(N)
    • If N % i = 0, append i in factors1 and Xor = Xor^i
    • And check If N / i != i, append N / i in factors2 and Xor = Xor^(n / i)
  • After executing the loop, insert elements of factors2 in factors1 in reverse order
  • Pop the element N from the factors1 vector.
  • Print the factors1 vector and return Xor^N as we have already calculated N in the Xor.

Below is the implementation of the above approach.

C++ 
// C++ code for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find all the divisors
// of N (excluding N) in sorted order
// and returning Xor of all factors of
// N except itself
int findAllFactors(int n)
{
    int Xor = 0;

    // To store factors from 1 to sqrt(n)
    vector<int> factors1;

    // To store factors from sqrt(n) to n
    vector<int> factors2;

    // Traverse from 1 to sqrt(n)
    for (int i = 1; i * i <= n; i++) {
        if (n % i == 0) {
            factors1.push_back(i);
            Xor ^= i;

            if (n / i != i) {
                factors2.push_back(n / i);
                Xor ^= (n / i);
            }
        }
    }

    // Append factors2 in factors1 in reverse order
    factors1.insert(factors1.end(), factors2.rbegin(),
                    factors2.rend());

    // Pop back 1 element from resultant
    // vector to remove N from factors
    factors1.pop_back();

    cout << "Divisors are: ";

    for (auto i : factors1) {
        cout << i << " ";
    }
    cout << endl;

    cout << "Xor: ";

    return Xor ^ n;
}

// Driver Code
int main()
{
    int N = 8;

    // Function call
    cout << findAllFactors(N) << endl;
    return 0;
}
Java 
import java.io.*;
import java.util.*;

public class GFG {
  static void findAllFactors(int N)
  {
    long Xor = 0;
    ArrayList<Integer> factor1
      = new ArrayList<Integer>();
    ArrayList<Integer> factor2
      = new ArrayList<Integer>();
    for (int i = 1; i * i <= N; i++) {
      if (N % i == 0) {
        factor1.add(i);
        Xor = Xor ^ i;
        if (N / i != i) {
          int M = N / i;
          factor2.add(M);
          Xor = Xor ^ (N / i);
        }
      }
    }
    for (int i = factor2.size() - 1; i >= 1; i--) {
      factor1.add(factor2.get(i));
    }
    System.out.println("Divisors are : " + factor1);
    Xor = Xor ^ N;
    System.out.println("Xor : " + Xor);
  }
  public static void main(String[] args)
  {
    int N = 8;
    findAllFactors(N);
  }
}

// This code is contributed by garg28harsh.
Python3 
# python code for the above approach
import math

# Function to find all the divisors
# of N (excluding N) in sorted order
# and returning Xor of all factors of
# N except itself
def findAllFactors(n):
    Xor = 0

    # To store factors from 1 to sqrt(n)
    factors1 = []

    # To store factors from sqrt(n) to n
    factors2 = []

    # Traverse from 1 to sqrt(n)
    for i in range(1, int(math.sqrt(n)) + 1):
        if (n % i == 0):
            factors1.append(i)
            Xor ^= i

            if (n // i != i):
                factors2.append(n // i)
                Xor ^= (n // i)

    # Append factors2 in factors1 in reverse order
    factors1 = factors1 + factors2[::-1]

    # Pop back 1 element from resultant
    # vector to remove N from factors
    factors1.pop()

    print("Divisors are: ", end="")

    for i in factors1:
        print(i, end=" ")

    print()

    print("Xor: ", end="")

    return Xor ^ n

# Driver Code
if __name__ == "__main__":

    N = 8

    # Function call
    print(findAllFactors(N))

    # This code is contributed by rakeshsahni
C# 
using System;
using System.Collections.Generic;
public class GFG
{
    static void findAllFactors(int N)
    {
        long Xor = 0;
        List<int> factor1 = new List<int>();
        List<int> factor2
          = new List<int>();
        for (int i = 1; i * i <= N; i++)
        {
            if (N % i == 0)
            {
                factor1.Add(i);
                Xor = Xor ^ i;
                if (N / i != i)
                {
                    int M = N / i;
                    factor2.Add(M);
                    Xor = Xor ^ (N / i);
                }
            }
        }
        for (int i = factor2.Count - 1; i >= 1; i--)
        {
            factor1.Add(factor2[i]);
        }
        Console.Write("Divisors are : ");

        foreach(int item in factor1){
            Console.Write(item + " ");
        }

        Console.WriteLine();
        Xor = Xor ^ N;
        Console.WriteLine("Xor : " + Xor);
    }
    public static void Main()
    {
        int N = 8;
        findAllFactors(N);
    }
}

// This code is contributed by Saurabh Jaiswal
JavaScript 
// Javascript code for the above approach

    // Function to find all the divisors
    // of N (excluding N) in sorted order
    // and returning Xor of all factors of
    // N except itself
    function findAllFactors(n)
{
    let Xor = 0;

    // To store factors from 1 to sqrt(n)
    let factors1 = [];

    // To store factors from sqrt(n) to n
    let factors2 = [];

    // Traverse from 1 to sqrt(n)
    for (let i = 1; i * i <= n; i++) {
        if (n % i == 0) {
            factors1.push(i);
            Xor ^= i;

            if (n / i != i) {
                factors2.push(n / i);
                Xor ^= (n / i);
            }
        }
    }

    // Append factors2 in factors1 in reverse order
    for (let i = factors2.length - 1; i >= 0; i--) {
        factors1.push(factors2[i]);
    }

    // Pop back 1 element from resultant
    // vector to remove N from factors
    factors1.pop();
    document.write("Divisors are: " + factors1);

    return Xor ^ n;
}

// Driver Code
let N = 8;

// Function call
console.log("Xor : " + findAllFactors(N));

// This code is contributed by garg28harsh.

Output
Divisors are: 1 2 4 
Xor: 7

Time Complexity: O(N1/2), where N is the given integer.
Auxiliary Space: O(N1/2), for storing all the factors of the given integer.


A

akashjha2671
Improve
Article Tags :

Explore

Lightbox