How do I explain what a “naive implementation” is? [closed]

Answer 1

A O(n!) algorithm.

foreach(object o in set1)
{
    foreach(object p in set1)
    {
        // codez
    }
}

This will perform fine with small sets and then exponentially worse with larger ones.

Another might be a naive Singleton that doesn't account for threading.

public static SomeObject Instance
{
     get
     {
          if(obj == null)
          {
               obj = new SomeObject();
          }

          return obj;
     }
}

If two threads access that at the same time it's possible for them to get two different versions. Leading to seriously weird bugs.

Answer 2

What's the most obvious, naive algorithm for exponentiation that you could think of?

base ** exp is base * base * ... * base, exp times:

double pow(double base, int exp) {
    double result = 1;
    for (int i = 0; i < exp; i++)
        result *= base;
    return result;
}

It doesn't handle negative exponents, though. Remembering that base ** exp == 1 / base ** (-exp) == (1 / base) ** (-exp):

double pow(double base, int exp) {
    double result = 1;
    if (exp < 0) {
        base = 1 / base;
        exp = -exp;
    }
    for (int i = 0; i < exp; i++)
        result *= base;
    return result;
}

It's actually possible to compute base ** exp with less than exp multiplications, though!

double pow(double base, int exp) {
    double result = 1;
    if (exp < 0) {
        base = 1 / base;
        exp = -exp;
    }
    while (exp) {
        if (exp % 2) {
            result *= base;
            exp--;
        }
        else {
            base *= base;
            exp /= 2;
        }
    }
    return result * base;
}

This takes advantage of the fact that base ** exp == (base * base) ** (exp / 2) if exp is even, and will only require about log2(exp) multiplications.

Answer 3

(Haven't seen a truly naive implementation posted yet so...)

The following implementation is "naive", because it does not cover the edge cases, and will break in other cases. It is very simple to understand, and can convey a programming message.

   def naive_inverse(x):
        return 1/x

It will:

• Break on x=0
• Do a bad job when passed an integer

You could make it more "mature" by adding these features.