Below you can choose a course (or two) and se the difference between them, you can also double-click on any given node to see only it’s immediate neighbors.

All courses have a central node (the bigger one) which basically is connected to all courses which don’t have dependencies.

For example, if you choose administracao_n_ss you can see all the courses from the business major at the Campina Grande campus, you can compare it with the same major but on a different campus (e.g: administracao_n_cg) you cann see how different they are, the one from the Campina Grande campus have more classes from different departments, and have a different topology, you can hover over the node to see their name (sorry they’re all in portuguese).

Have Fun!!

Also Know as Sertão.

Originally the term referred to the vast hinterlands of Asia and South America that Lusitanian explorers encountered. In Brazil it referred to backlands away from the Atlantic coastal regions where the Portuguese first settled in South America in the early sixteenth century. A Brazilian historian once referred to colonial life in Brazil as a “civilization of crabs”, as most settlers clung to the shoreline, with few trying to make inroads into the sertão. In modern terms, “sertão” refers to the semi-arid region in Northeastern Brazil comprising parts of the states of Alagoas, Bahia, Pernambuco, Paraíba, Rio Grande do Norte, Ceará, Maranhão, Piauí, and parts of northern Minas Gerais. The term Vaqueiro is similar to the generic use of “cowboy” in the United States.

Geographically, the sertão consists mainly of low uplands that form part of the Brazilian Highlands. Most parts of the sertão are between 200 and 500 meters above sea level, with higher elevations found on the eastern edge in the Planalto da Borborema, where it merges into a sub-humid region known as agreste, in the Serra da Ibiapaba in western Ceará and in the Serro do Periquito of central Pernambuco. In the north, the sertão extends to the northern coastal plains of Rio Grande do Norte state, whilst in the south it fades out in the northern fringe of Minas Gerais. Two major rivers cross the sertão, the Rio Jaguaribe and the Rio Piranhas further east. Apart from the Rio São Francisco, which originates outside the region, other rivers dry out after the rainy periods end.

Visualizing info about it

Let’s plot some maps of this region with some interesting data.

Quantity of water supply stops

Let’s see which cities had the highest rate of stop in the water supply. We’re using a continuos color scale from blue to red, which means that the lower the number of water supply stops during the year of 2015 the bluer the city is and the more stops we have the city is in a darker shade of red. Grey cities show are cities on which we don’t have data.

Regions with the highest demand for water

Let’s see where is concentrated the highest number of people with water supply, so we can see which regions has the highest demand for water. We’re using a color scale from light blue to dark blue, the higher the demand the darker is the shade of blue. Grey cities show are cities on which we don’t have data.

If the City Has Selective Waste Collection or Not

Let’s see which cities have selective waste collection or not, cities in green have it and cities in red don’t have it. Grey cities show cities on which we don’t have data.

This chart is an improvement on a colleague work, which can be found here.

I tried to improve the information communication channel, by using a heat map. The use of a heat map allowed us to have a better insight on the hours and days of the week on which the people who completed the survey perceived their selves as the most random.

The previous chart also used mean to aggregate all the users that answered on a given time slot, I choose to use median, since is a more robust metric to outliers, people who perceived theirselves as really bad(0) or really random (10).

Without further ado…

Here is the chart

Insights

What this visualization tell us, is that first we probably have more people answering the form on Thursday; Second, it tell us that the majority of people tend to think that they are not that random.

We need more data, specially data from different days of the week, but we can see from the visualization that we probably don’t have a great correlation between day of the week/hour and how random a person perceive itself.

Overview

In computer science, a linked list is a data structure consisting of a group
of nodes which together represent a sequence. Under the simplest form, each
node is composed of a data and a reference (in other words, a link) to the
next node in the sequence; more complex variants add additional links. This
structure allows for efficient insertion or removal of elements from any
position in the sequence.

Linked Lists are really simple data structures, we only have to remember when solving problems that involve them, to notice if we’re using singly linked lists (only have links to the next node) or doubly linked lists (links for previous and next nodes).

CODE!

Enough talking let’s start coding. First you should note the elements that a Linked List have, I see two of them, a Node and obviously the Linked List in itself, which if you think we could represent as a Node, we only need the Head of a Linked List to represent it.

So let’s create two classes in python, Node that is going to serve as a container for the data, and LinkedList that is going to provide us with different methods to manipulate the data structure.

1
2
3
4
5
6
7

class _Node(object):
   def __init__(self, data=None, next=None):
      self.data = data
      self.next = next
   def __str__(self):
      return str(self.data)

There is only two things to note on our implementation of Node, first we’re declaring it as a protected class, eventhough Python don’t have a true protected notion, it’s more of a notation, but I’m digressing here, the other interesting thing is that we’re rewriting the __str__ method from object, Node’s superclass, so every time we print our Nodes we’re going to see the data they store, which in my opinion makes more sense.

Now let’s see our biggest class, LinkedList:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class LinkedList(object):
   def __init__(self):
      self.length = 0
      self.head = None
   def __str__(self):
      return self._toString()
   def __len__(self):
      return self.length
   def _toString(self):
      node = self.head
      string_to_return = []
      # Print the value of the nodes
      while node:
      string_to_return.append('%s ' % node)
      node = node.next
      return ''.join(string_to_return).strip()

There are two things worth noting in this part of our class, first we’re rewriting the method __len__ from object, which permit us call len in our LinkedList, also note we’re using a list to accumulate the string in the _toString method, this is to avoid waste of space, since strings are immutable in python, using something like += will result in many objects.

1
2
3
4
5
6
7
8
9
10
11
12
13

def add(self, data):
   if self.head is None:
      self.head = _Node(data=data)
      self.length += 1
   else:
      node = self.head
      while node:
         if node.next is None:
            node.next = _Node(data=data)
            self.length += 1
            break
         else:
            node = node.next

Our add method, is pretty straight forward, if our Linked List is empty (head is None) we create a new node as head. If not, we find the tail of list, and insert our new Node after it.

1
2
3
4
5
6
7

def index(self, x):
   for i in range(self.length):
      if node.data = x:
         return i
      else:
         node = node.next
   raise Exception('Item Not Found!)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def remove(self, x):
   # case is empty
   if self.head is None:
      raise Exception('Trying to remove from empty list')
   # case is head
   elif self.head.data == x:
      self.head = None
      self.length -= 1
   # other cases
   else:
      node = self.head
      while node:
         if node.next is None:
            raise Exception('Item Not Found!')
         elif node.next.data == x:
            node.next = node.next.next
            self.length -= 1
         else:
            node = node.next

We finally get to our final methods, index, which provide us the index of a given Node, if it exists, and remove which as the name says remove some node given the data it contains.

The End

Well folks that was it, as an exercise try to implement a doubly linked list, without looking to the code here, so you could make sure that you’re truly understanding linked lists, and not simply rewriting the code.

image by Marina Molineiro