Check whether a number is Quasiperfect number or not.

A Quasiperfect number is a positive integer that is equal to the sum of all its proper divisors plus or minus one. In other words, a number n is quasiperfect if the sum of all its proper divisors is either n+1 or n-1.

Examples:

Input: 20
Output: NO
Explanation: The divisors of 20 are 1, 2, 4, 5, 10 and 20. The sum of these divisors except 20 is 1+2+4+5+10=22, which is not equal to 20-1 or 20+1. Therefore, 20 is not a quasiperfect number.
Input: 28
Output: YES
Explanation: 28 is a quasiperfect number because its divisor divisors are 1, 2, 4, 7, and 14, and the sum of these divisors is 28. Therefore 28 is a quasiperfect number.

Approach 1: Bruteforce Approach

To solve the problem follow the below idea:

The given approach is to check if a number is a Quasiperfect number or not. It iterates through all the possible divisors of the given number and calculates the sum of those divisors. If the sum of divisors is equal to the given number or less than one of that, it returns true, indicating that the given number is a Quasiperfect number.

Below are the steps for the above approach:

• Initialize a variable sum = 0.
• Run a for loop to iterate from 1 to n/2, and check if each number is a divisor of n. If it is, add it to the sum.
• Check if the sum is equal to n+1 or n-1, print YES else print NO.

Below is the Code of the above approach:

C++

// C++ code for the above approach:
#include <iostream>
using namespace std;

bool is_quasiperfect(int n)
{
    int sum = 0;
    for (int i = 1; i < n; i++) {
        if (n % i == 0) {
            sum += i;
        }
    }
    if (sum == n + 1 || sum == n - 1)
        return true;
    else
        return false;
}

// Drivers code
int main()
{
    int n = 28;
    if (is_quasiperfect(n)) {
        cout << "YES";
    }
    else {
        cout << "NO";
    }
    return 0;
}

Java

// Java code for the abvoe approach:

import java.io.*;

class GFG {

  static boolean is_quasiperfect(int n)
  {
    int sum = 0;
    for (int i = 1; i < n; i++) {
      if (n % i == 0) {
        sum += i;
      }
    }
    if (sum == n + 1 || sum == n - 1) {
      return true;
    }
    else {
      return false;
    }
  }

  public static void main(String[] args)
  {
    int n = 28;
    if (is_quasiperfect(n)) {
      System.out.print("YES");
    }
    else {
      System.out.print("NO");
    }
  }
}

// This code is contributed by sankar.

Python3

# Python code for the above approach
def is_quasiperfect(n):
    sum = 0
    # looping through 1 to n
    for i in range(1, n):
      # if n is divisible by i
        if n % i == 0:
            sum += i
    if sum == n + 1 or sum == n - 1:
        return True
    else:
        return False


# Driver's code
n = 28
# function call
if is_quasiperfect(n):
    print("YES")
else:
    print("NO")

# This code is contributed by Vaibhav Nandan

C#

// C# code for the above approach:
using System;

class GFG {

static bool is_quasiperfect(int n)
{
    int sum = 0;
    for (int i = 1; i < n; i++) {
    if (n % i == 0) {
        sum += i;
    }
    }
    if (sum == n + 1 || sum == n - 1) {
    return true;
    }
    else {
    return false;
    }
}

public static void Main()
{
    int n = 28;
    if (is_quasiperfect(n)) {
    Console.Write("YES");
    }
    else {
    Console.Write("NO");
    }
}
}

// This code is contributed by Pushpesh Raj

Javascript

// Define a function called isQuasiperfect that takes an integer n as input.
function isQuasiperfect(n) {
    // Initialize a variable sum to 0. This variable will store the sum of divisors.
    let sum = 0;

    // Loop through numbers from 1 to n-1.
    for (let i = 1; i < n; i++) {
        // Check if i is a divisor of n (n is divisible by i).
        if (n % i === 0) {
            // If i is a divisor, add it to the sum.
            sum += i;
        }
    }

    // Check if the sum of divisors is equal to n+1 or n-1.
    // If it is, return true, indicating that n is quasiperfect.
    // Otherwise, return false.
    return sum === n + 1 || sum === n - 1;
}

// Define a constant variable n with the value 28.
const n = 28;

// Check if n is quasiperfect using the isQuasiperfect function.
if (isQuasiperfect(n)) {
    // If n is quasiperfect, print "YES" to the console.
    console.log("YES");
} else {
    // If n is not quasiperfect, print "NO" to the console.
    console.log("NO");
}

Output

NO

Time Complexity: O(N)
Auxiliary Space: O(1)

Approach 2: To solve the problem follow the below idea:

we can get a number divisors in √N time.

Below is the Code of the above approach:

C++

// C++ implementation
#include <iostream>
using namespace std;

// check number n is quasiperfect or not
bool is_quasiperfect(int n)
{
    int sum = 0;
    for (int i = 1; i * i < n; i++) {
        if (n % i == 0) {
            // adding divisor(i) to sum variable
            sum += i;
            // also adding divisor(n/i) to sum variable
            sum += n / i;
        }
    }
    if (sum == n + 1 || sum == n - 1)
        return true;
    else
        return false;
}

// Drivers code
int main()
{
    int n = 28;

    // function call
    if (is_quasiperfect(n)) {
        cout << "YES";
    }
    else {
        cout << "NO";
    }
    return 0;
}

Java

// Java Implementation
import java.io.*;

class GFG {
    // check number n is quasiperfect or not
    public static boolean is_quasiperfect(int n)
    {
        int sum = 0;
        for (int i = 1; i * i < n; i++) {
            if (n % i == 0) {
                // adding divisor(i) to sum variable
                sum += i;
                // also adding divisor(n/i) to sum variable
                sum += n / i;
            }
        }

        if (sum == n + 1 || sum == n - 1) {
            return true;
        }
        else {
            return false;
        }
    }

    public static void main(String[] args)
    {
        int n = 28;

        // function call
        if (is_quasiperfect(n)) {
            System.out.print("YES");
        }
        else {
            System.out.print("NO");
        }
    }
}

Python3

# Check if a number n is quasiperfect or not
def is_quasiperfect(n):
    sum_divisors = 0
    for i in range(1, n):
        if n % i == 0:
            # Adding divisor(i) to the sum variable
            sum_divisors += i
            # Also adding divisor(n/i) to the sum variable
            sum_divisors += n // i

    if sum_divisors == n + 1 or sum_divisors == n - 1:
        return True
    else:
        return False

# Driver code
n = 28

# Function call
if is_quasiperfect(n):
    print("YES")
else:
    print("NO")

#Contributed by Aditi Tyagi

C#

// C# Implementation
using System;

class GFG {
    // check number n is quasiperfect or not
    public static bool is_quasiperfect(int n)
    {
        int sum = 0;
        for (int i = 1; i * i < n; i++) {
            if (n % i == 0) {
                // adding divisor(i) to sum variable
                sum += i;
                // also adding divisor(n/i) to sum variable
                sum += n / i;
            }
        }

        if (sum == n + 1 || sum == n - 1) {
            return true;
        }
        else {
            return false;
        }
    }

    public static void Main()
    {
        int n = 28;

        // function call
        if (is_quasiperfect(n)) {
            Console.Write("YES");
        }
        else {
            Console.Write("NO");
        }
    }
}


// This code is contributed by Utkarsh Kumar

Javascript

// Javascript implementation

// check number n is quasiperfect or not
function is_quasiperfect(n) {
    let sum = 0;
    for (let i = 1; i * i < n; i++) {
        if (n % i === 0) {
            // adding divisor(i) to sum variable
            sum += i;
            // also adding divisor(n/i) to sum variable
            sum += n / i;
        }
    }
    if (sum === n + 1 || sum === n - 1)
        return true;
    else
        return false;
}

// Drivers code
let n = 28;

// function call
if (is_quasiperfect(n)) {
    console.log("YES");
}
else {
    console.log("NO");
}

Output

NO

Time Complexity: O(√N) , since we can calculate number divisors in square-root(n) time.
Auxiliary Space: O(1)