How-To

findClosestToEnd

Let's say we are writing the algorithm (p-code) for the method "findClosestToEnd".

The method header is shown to the right.

Remember, we are coding in a MyArray object -- so it is part of our context (environment).

findClosestToEnd(compareFct) {
	//ALGORITHM HERE
}

Scribble Human Language Algorithm

First we'll just scribble out a quick "rough" algo in any human language for the purpose is just helping us get going with pseudocode.

Note for the two searches we use the arg "compareFct" that is provided to the algorithm.

findClosestToEnd(compareFct) {
	firstIndex = get index of first (left) end of array
	lastIndex = get index of last (right) end of array
	firstMatchingIndex	= search for first matching elem (index)
	lastMatchingIndex = search for last matching elem (index)
	leftDistance = distance from firstIndex to the firstMatchingIndex
	rightDistance = distance from lastMatchingIndex to the lastIndex
}

Human Language Algorithm Iter #2

Algos are all about iteration. Here is our second, improved, scribble of our "human" algorithm.

We can see that four of the steps require only simple math.

But the other two steps (searches) are going to require some serious work.

findClosestToEnd(compareFct) {
	firstIndex = 0
	lastIndex = this.length - 1
	firstMatchingIndex	= search for first matching elem (index)
	lastMatchingIndex = search for last matching elem (index)
	leftDistance = firstMatchingIndex - firstIndex
	rightDistance = lastIndex - lastMatchingIndex
}

Reuse! 💡

But wait! What is our context/scope? What other objects and algorithms (methods) do we have available?

We know have "MyArray" (the object we are coding in -- i.e. "this").

The question is, does it provide a method(s) that will help us with the searches?

	firstMatchingIndex = search for first matching element (index) using compareFct
	lastMatchingIndex = search for last matching element (index) using compareFct

Finding Helper Method

Browsing a MyArray listing, we see an algorithm (method) named findIndex

If we read about that algorithm, we learn it does exactly what we need for our search to find the first matching index.

We should also look for something similar for finding the last matching index.

MyArray algorithms (methods) menu:

indexOf*
join*
findIndex*
findLastIndex*
occurrences*
reversed
...

Add a Helper Algorithm 💡

If we do not find a algorithm (method) that will do the job we may still consider adding a helper algorithm to make our current algorithm simpler.

One Return Statement at End of Logic

Here we take the approach of keeping a "result" variable.

We can work to get this to give the correct results.

However, the logic is complex. This is a welcoming environment for bugs.

Also, as we'll learn below, that this is very inefficient.

Generally coders try to shy away from deep, nested bracing.

static isPrime(n) {
	let result;
	if (n <= 1) {
		result = false;
	} else {
		if (n == 2) {
			result = true;
		} else {
			if (n % 2 == 0) {
				result = false;
			} else {
				if (n <= 7) {
					result = true;
				} else {
					result = true
					let max = Math.sqrt(n)
					let factor = 3
					while (factor <= max) {
						if (n % factor == 0) {
							result = false;
						}
						factor += 2;
					}
				}
			}
		}
	}
	return result;
}

Simplified with Return Statements

The main things that we do differently in this try are:

Look for special conditions at the start of the logic and return when they are found
When we find the result (e.g., when we find a factor, we return immediately

Benefits:

The code is so much simpler. The main logic is now just a very short while loop.
Much more efficient than the previous because when a result is known it is returned and the logic ends its work.

static isPrime(n) {
	// Special Cases
	if (n <= 1) return false;
	if (n == 2) return true;
	if (n % 2 == 0) return false;
	if (n <= 7) return true;
	let max = Math.sqrt(n)
	let factor = 3
	// "Return" if we find result
	while (factor <= max) {
		if (n % factor == 0)
			return false;
		factor += 2;
	}
	return true;
}

Side-by-Side Comparison

One Return Statement at End of Logic

static isPrime(n) {
	let result;
	if (n <= 1) {
		result = false;
	} else {
		if (n == 2) {
			result = true;
		} else {
			if (n % 2 == 0) {
				result = false;
			} else {
				if (n <= 7) {
					result = true;
				} else {
					result = true
					let max = Math.sqrt(n)
					let factor = 3
					while (factor <= max) {
						if (n % factor == 0) {
							result = false;
						}
						factor += 2;
					}
				}
			}
		}
	}
	return result;
}

Simplified with Return Statements

static isPrime(n) {
	// Special Cases
	if (n <= 1) return false;
	if (n == 2) return true;
	if (n % 2 == 0) return false;
	if (n <= 7) return true;
	let max = Math.sqrt(n)
	let factor = 3
	// "Return" if we find result
	while (factor <= max) {
		if (n % factor == 0)
			return false;
		factor += 2;
	}
	return true;
}