algorithms on Andrés Álvarez

Big O Notation - Omega & Theta

Wed, 16 Nov 2016 00:00:00 +0000

In a previous post I went over the basic and most common Big O notations along with respective common algorithms, and finally adding some Ruby benchmarks for each.

However I did not cover some other very important concepts in Big O notation: Omega and Theta.

Understanding Omega

The Omega symbol (Ω) represents a certain algorithm's best-case asymptotic complexity. For example, let's take again a look at the binary search algorithm:

Previously we determined that the Big O notation for this algorithm is O(log n). This represent the worst asymptotic complexity that the algorithm can possibly have.

Ruby Benchmarking & Big O Notation

Tue, 15 Nov 2016 00:00:00 +0000

The Ruby Benchmark library helps us to measure how long it takes for a block of code to run. Similar to when you subtract starting time and ending time in other languages such as Java.

I was doing some Big O Notation reviewing with Ruby the other day and did some common algorithm implementations for each of the most common Big O notations, just for fun.

Using Benchmark

To start benchmarking our code, we simply need to require benchmark and use the methods provided by the Benchmark module. For me, the most practical way is to use Benchmark#bm method, where we pass a block of code we want to measure:

require 'benchmark'

Benchmark.bm do |x|
  x.report do
    # our code here
  end

end

Inside the block we are using the report method of the block's variable, which will basically do a separate benchmark for each report.

However, we can improve this even more by adding a label to report and a label width to bm:

require 'benchmark'

Benchmark.bm(20) do |x|
  x.report("my_algorithm") do
    # our code here
  end
end

Let's see it in action with some common algorithms.

Infinite Sequences in Ruby Using Enumerator

Mon, 14 Nov 2016 00:00:00 +0000

The Enumerator class in Ruby allows us to generate some very smooth and useful infinite sequences. For example, in some Project Euler problems it is required to generate sequences without a specific limit. A good example of this is the Highly Divisible Triangular Number problem:

The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...

Let us list the factors of the first seven triangle numbers:

     1: 1
     3: 1,3
     6: 1,2,3,6
    10: 1,2,5,10
    15: 1,3,5,15
    21: 1,3,7,21
    28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over five divisors.

What is the value of the first triangle number to have over five hundred divisors?

So first we would want to be able to generate a (infinite) sequence of triangular numbers that we can use to do many programming operations, such as iterating over the sequence.