My thoughts, too. I've done everything so far in Python 3, pity that I either switch to another language or forgo completing this programming problem.

Python doesn't support interfaces(and doesn't need to). Python has powerful multiple inheritance anyways, so languages like Java which have single inheritance only have to cope by inculcating "implementable" interfaces.

what is wrong in my code.Iam not get output public int divisorSum(int n) { int sum =0; int i=0; while( i<=n) { if(n%i==0) sum=sum+i; i++; } return sum; }

Sadly, I, too, had to fall back to annother language. I choose C# and I had to remember the semicolons and variable declaration.

This is what i found on stackoverflow

Because Python doesn't have (and doesn't need) a formal Interface contract, the Java-style distinction between abstraction and interface doesn't exist. If someone goes through the effort to define a formal interface, it will also be an abstract class. The only differences would be in the stated intent in the docstring.

And the difference between abstract and interface is a hairsplitting thing when you have duck typing.

Java uses interfaces because it doesn't have multiple inheritance.

http://stackoverflow.com/questions/372042/difference-between-abstract-class-and-interface-in-python

This is lame, they should ask us to answer with an abtract class in Python...

crying to see there's no such an option.....won't be able to complete all 30 questions, unless I turn back to learn Java T.T

This would do it in python:

x = int(input("your input"))

sum = 0 for i in range(1, x + 1): if x % i == 0: sum += i else: i += 1 return sum

PYTHON3 SIMPLE SOLUTION!

x = []
for i in range(1, n+1):
    if n % i == 0:
        x.append(i)
    else:
        pass
return sum(x)

basically u just need to make a fucntion to check if a n is divisible by a number from 1 to 1000 or not, and summ all the numbers that are divisors of n.

class Calculator(AdvancedArithmetic):
    def divisorSum(self, n):
            p=0
            e=0
            for i in range(1,1001):
                e=(n%i)
                if e==0:
                    p+=i
            return p
            pass

class Calculator(AdvancedArithmetic): def divisorSum(self, n): factor_sum = 0 for i in range(1, n+1): if n % i == 0: factor_sum += i return(factor_sum)

I like this one, it's clean and easy to follow.

Also, since it's a one liner for loop, you should be able to getaway with removing the curley braces.

for (int i = 1; i <= n; i++) 
  if (n % i == 0) sum += i;

at least you could stop checking at n/2 and add n at the end

Simple code is the best :)

You missed the bounds checks.

if (n >= 1 || n  <= 1000) {...

Performance geek here. Nice job. You might want to try improving the runtime by only iterating up to the square root of n instead of n like this to improve your runtime from O(n) to O(n^(1/2)).

Hope this helps.

HackerRank solutions.

I am on your side! My code is similar to yours - one for loop, simple and clean.

Better use ternary for 1 liner if.

struct Calculator : public AdvancedArithmetic
{
    int divisorSum(int n)
    {
        int sum = 0;
        for(int i = n; i > 0; --i)
            sum += n%i ? 0 : i;
        return sum;
    }
};

Did your code compile? Because they told us to not use the public keyword for class definition, only for method definition...because were defining multiple classe in one file.☝

At least only do the loop up to sqrt of n lol

can you please share us where i can find that n^1/2 is better than n ?

can you please tell me why you negation of the sum.

I added some optimisations(there is the half of operations if the number n is odd).

What do you think about it?

class Calculator : public AdvancedArithmetic {
public:
    int divisorSum(int n) {
        int sum = n + 1;
        const int s = sqrt(n);
        const int di = 1 + (n & 1);

        for(int i = di + 1; i <= s; i += di) {
            if (n % i == 0) {
                sum += i + n / i;
            }
        }

        if (s * s == n) sum -= s;
        return sum;
    }
};

little optimezd solution -

https://www.hackerrank.com/challenges/30-interfaces/forum/comments/574259

same here. Case #6 is wrong for my solution although the answer is correct. I'm starting to believe that it is the missing string part of the output that's making it a wrong answer for HR.

This is fixed now, sorry for the inconvenience.

I actually did that overkill (even though we are limited to ints instead of even longs).

    public int divisorSum (int N){
        HashMap<Integer,Integer> primeFactorization = factor(N);
        int total = 1;
        for (int p:primeFactorization.keySet()) {
            System.err.println("considering prime: " +p + " with mult: "+ primeFactorization.get(p));
            int factor = 1;
            for (int i=0;i<primeFactorization.get(p);i++) {
                factor*=p;
                factor+=1;
            }
            total*=factor;
        }

        return total;
    }
    private HashMap<Integer,Integer> factor(int n){
        HashMap<Integer,Integer> mii = new HashMap<>();
        if(isPrime(n)){
            mii.put(n,1);
            return mii;
        }
        if (n%2==0){ 
            int m = n;
            int cnt=0;
            do{
                m/=2;
                cnt++;
            }while(m%2==0);
            mii.put(2,cnt);
        }
        double ceil = n/2.0;
        for (int i = 3; i <= ceil; i += 2) {
            if ((isPrime(i)) && (n%i == 0)) {
                int m = n;
                int cnt=0;
                do{
                    m/=i;
                    cnt++;
                }while(m%i==0);
                mii.put(i,cnt);
            }
        }
        return mii;
    }

    private static boolean isPrime(int num) {
        if (num < 2) return false;
        if (num == 2) return true;
        if (num % 2 == 0) return false;
        for (int i = 3; i * i <= num; i += 2)
            if (num % i == 0) return false;
        return true;
    }

You may use wheel factorization and the divisor function. It is a bit tricky, but the resulting code is not too much complicated (just two cycles). Implementing the sieve, you have not to test if the divisor is actually prime.

An elegant solution indeed. Thank you for sharing.

I think it's because you can use Abstract Base Classes to accomplish that, so they didn't want to have a 'duplicate' lesson.

Nice job. You might want to try improving the runtime by only iterating up to the square root of n instead of n like this to improve your runtime from O(n) to O(n^(1/2)).

Hope this helps.

HackerRank solutions.