William Granados

Investments Basics

2021-01-24T00:00:00+00:00

So upon graduation, me like any other student has come across the question, what now? Well if you’re lucky maybe you’ll have a job, and this will help you get started in the right direction.

Income

There’s a couple of ways to make money, but one of the most common include salaried jobs. There are a couple of ways that people in tech get compensated but most follows the pattern of: (Cash)

signing bonus
performance bonus
annual salary

(Equity)

Residual Stock Units (RSU), or options

Most cash based compensation are straight foward, equity based compensation is a bit different.

If your company is public and is trading shares in the NASDAQ or TSX then you will likely get RSU. These usually consist of a grant date that locks the intial price of your stock, then a vesting period (usually 1 year).

If your company is pre-ipo you will likely get stock options and than you can exercise these options (i.e. purchase as set price below IPO price) once a company IPOs. These usually have a set 6 month period before you can decide to sell.

Deductions (i.e. Taxes)

The not so fun part of income taxes, these usually contain the federal and provincial portion of the your taxes, along with payments to cpp/ei. Canada has a tier based tax system that I will try to explain (image obtained from taxtips.ca). Here the terminology you need to know:

Other Income: This includes your cash based and equity based compensation.

Capital gains: These are taxes on when holding stock investments. An example: vested stocks that you didn’t sell that increased in price would be taxed under this column.

Dividends: This is passive income you receieve from something like bonds

Marginal Tax Rate: That highest tax bracket you’re in. I.e. if you earned $1000 more in your annual income, your highest tax bracket determines how much of that you’ll keep.

Average Tax Rate: The average of tax paid in all brackets, usually it’s something like 33% of your yearly income. This is useful for calculating your take home income after taxes.

Debts / Student loans

Most students in ontario take out OSAP whias is split up in a federal and provincial portion of your loan. These interested on each portion is calculated as the prime rate (around 2.45% in 2021), along with a flat amount (0% for federal, 3% for provincial). In my experience the provincial part is pretty low, so I’d effectively be paying a 3% interest for my loan.

Tax advantaged accounts

Usually you’d be taxed captial gains on your investments, but these are special accounts provided by the government that help you dip your toes into investments.

RRSP

The maximum amount that you can deposit per year to this type of account is the minimum of 20% of your income or $29210 (source). Any money withdrawn cannot cannot increase your deposit limit (hence you lose the benefit of compound interest).

These deposit can be carried over to the next year. But the important these contributions can be used as a tax deduction. You can think of it as a hyperbolic time chamber where you would the taxes you would normally at a later date. Upon withdrawel any item you would withdraw is counted as other income (which you can refer to above).

Ideally if you’re working and in a higher tax bracket (i.e. 45% marginal tax bracket), if you were to be at a lower tax bracket later (i.e. retired), then you could withdraw from it and be in a lower marginal tax rate (i.e. 20% for up to 45k). So you ideally pay less taxes and can pay for retirement.

Some employers also offer employee matching up to a certain percent of your annual income (i.e. 3%). These are great because you can think of it as free money in the future!

Another advantage of your is you may be eligble for the HBP. This allows first time home buyers to withdraw up to 35k tax free from their RRSP that can be towards your home purchase. This you normally have to pay back in full after 10 years. but it’s pretty good since because you can your pretax money to work as an interest free loan.

TFSA

The maximum amount you can deposity per year is generally $6000, and this is accumlated from the year you turn 18 (sorry if you’re younger you can’t have one :( ). You never have to pay any forms of taxes on gains in these account (yay). If you withdraw money than your maximum deposit gets refreshed the following year.

These are really great because you don’t have to pay capital gains on any income, and you can freely withdraw money without it pushing you to a higher tax bracket.

Investment Options

There’s a distriction between passive and active investments strategies for these accounts.

Generally big banks like to actively invest in your accounts (i.e. mutual funds, hand picking stocks/bonds) and they charge alot, while other places invest in index funds (i.e. ETFS) that model the market.

A popular passive investment platform is the robo advisor WealthSimple because it’s hand free and you don’t have to pick investments yourself. If you want to actively invest you can try WealthSimple Trade.

Budgeting

The following is a spreadsheet I made with the help of some friends to make budgeting easier. Good luck!

Why I play a text based game in 2020

2020-01-18T00:00:00+00:00

So I get a lot of comments when people learn that I’ve been playing a bland looking RPG for the past 10 years. Well, today, I plan to take a trip down memory lane.

The Game: Torn City

To give you an idea of what the game is like, let’s look at the description: “Torn is a text-based online RPG set in Torn City, a dark, murky underworld where only the sharpest survive. In Torn City you can be anyone and do anything. Build your character to infinite strengths and play it.”

Now, how can such a bland looking game manage to keep my attention for the past 10 years, you may ask? Well, it’s actually a very feature rich text-based game that has many people around the globe addicted. I’ve known of several people who tried to quit the game, only to come back to it in a few years full circle. What could possibly be the reason for this?

The Community

Torn is a very diverse community attracting player sfrom all over the world. x`

Gameplay

Most of your time consists of hitting the gym.

doing missions

travelling for money

trading items

faction wars / chaining

trolling on forums

signature making

doing crimes / making money

Some interesting links: Game creator becomes a millionare , Torn City news Eps 32

The Older Past(10 yrs ago)

I’m about 3900 days old today, which means I made my account around May 2009. My first encounter with the game was a few years back on a school computer (2007-2008).

When I first encountered the game, I didn’t think much of it. I mean, the grey colour is not all that appealing to the eye. And honestly I have forgotten the password/username/email associated with that account. It wasn’t until a few years later that I found my cousin playing Torn and this caught my interest again.

Back in those days the only popular games I knew of were playing with fire, and newgrounds. I also had a pretty slow computer so I couldn’t really play any intensive games like runescape.

While I was playing these games I met a lot of cool people from around the world, who resided in: UK, Scotland, UAE, and from the US. I learned a lot about their cultures, and I remember spending nights on messengers talking about hunting the wild haggis. Most of these people were from a different game I played at the time called city struggle, however that game was shut down sometime around 2011, due to unforeseen reasons. So a lot of us migrated to torn city, and the few who didn’t remain a mystery (like ViralVengeance, leader of Deviance).

So, since CS was a pretty big part of my life, I stayed in contact with the few people still on torn. But over the next year those people became less active. This lonesome year resulted in me taking a three year hiatus (around the time highschool started).

The Old Past (6 yrs ago)

During my final year of highschool around the time I was stressing about getting into University, I decided to take a break from it all and play a little bit of torn. One thing led to another and I found myself now trying to reach the “stat cap” milestone in each category. I thought to myself if I was gonna get serious at any point in this game, having reached the stat cap would be useful.

It was around this time I made a new group of friends in a faction called Sadistic which was run by a business student in Myanmar, and US veteran. While I was there I learned about “chaining” attacks feature which involved users staying up to make attacks on other users in 5 min windows, to raise a hit counter. This was pretty fun since it required a lot of communication and grit to be able to get some longer chains going like the 500 ones. Unfortunately this experience didn’t last long when the team disbanded, so I joined a bigger faction at the time called Momento Mori (M†M).

I started getting more involved in the scene since M†M was a top 20 faction at the time. They weren’t pushovers either, and they frequently did much longer chains than the ones in Sadistic (in the realm of 1000-5000) since they had a larger active userbase. I leanrned a fair bit of warring and chaining from that faction which I’m very grateful for. Unfortunately this faction didn’t last long either once the leader Tascon decided to sell it.

The Somewhat Present - Now (2 yrs ago)

At this point I managed to reach the goal I wanted but I wasn’t really fully set on the game, so I decided to join another top 20 faction called destructive angels (sister faction of destructive anomoly [top 5 faction]). I thought, “maybe I could move up to the top faction”. Unfortunately, this faction ended up disbanding disbanding. And at the time I remember how difficult it would be to have 10k chains.

So I decided I wanted to join a really active faction where I could basically be lazy asf and just throw in my hits during the exam season without worrying to keep the chain alive. So at the time I remember seeing 39th Street Killers X (X stands for elite) they were doing 25k chains effortlessly over weekends and pulling in a lot of money through organised crimes. Keep in mind a 10k chain might take me a week to do in my old factions, so I was very impressed. I talked with the faction leader, told him about my history and I mentioned the points above, and just like that I was in. After years of not being sure if I’d play legitimately I was now in a top 5 faction, and my overall in game stats were starting to look a lot better.

I’ve been in the faction for a year now and moved up to main faction (39th Street Killers), and honestly I feel like my decision back then was right. There are lots of smart and dedicated people here, and I feel like I keep meeting new intersting people. Well let’s see how long this will last :)

CCC/CCO Selected Solutions (2010-2014)

2020-01-10T00:00:00+00:00

Introduction

I actually wrote all of editurials when I was in highschool, and had them on my old blog. I removed it because I couldn’t find a good way to organize it at the time, but now I have a better idea. I hope anyone thinking of competiting in this competition will find these useful :)

Solution for CCC10S3 - Firehose

This problems asks us to find the minimum length of hose required to connect a series of houses if were only given K fire hydrants from which to extend our hose from. We must then take into consideration the maximum hose length possible is 1,000,000, because this number is so large we know that a simple iterative solution will likely not run in time. What we need to notice is that once we have found one possible hose length that satisfies the condition above we do not need to consider hose lengths that are longer, likewise we also have to notice that if the current hose length does not satisfy the conditions then all hose lengths less than this hose length are also impossible. Once we see this property the problem becomes a trivial binary search problem, we’re using binary search on the hose length. te

Now that this idea has been formulated we must define a predicate. The predicate should be if the current hose length is possible then the upper bound is now the hose length, otherwise the lower bound is now equal to the hose length. In provided solution the predicate written has a time complexity of $O(H^2)$ where $H$ is the number of houses and the binary search has a time complexity of $O(\log{}L)$ where $L$ is the length of the hose.

Time complexity: $O(H^2\log{}L)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include
#include
#include
#include
#include
using namespace std;

const int MAXH = 1000;
int H,K,lo,hi,mid;
vector<int>house;
bool v[MAXH];


/*minimum between distance taking wrapping into consideration*/
int dist(int h1,int h2){
  return min(h2-h1,(int)1e6-h2+h1);
}

/* Places a hydrant hose_len units away from the current house. 
 * For all houses in front of the current house, if their 
 * distance from the current house is * less than or equal to
 *  2*hose_len meaning they are either on the left side of the 
 * hydrant (placed hose_len units ahead of the current house) or on the 
 * right side of the hydrant (hence the extra hose_len) then they 
 * are marked as visisted.
 */
bool predicate(int hose_len,int k_left = K,int h_left = H){
  memset(v,false,sizeof(v));
  for(int i = 0;i < (int)house.size() && h_left > 0 && k_left > 0;++i){
      if(v[i])
        continue;
      else{
        k_left--,h_left--,v[i] = true;
        for(int k = (i+1)%H;k < (int)house.size();++k){
            if(!v[k] && dist(house[i],house[k]) <= 2*hose_len)
                h_left--,v[k] = true;
            else
                break;
        }
      }
  }
  return (h_left == 0) ? true:false;
}

int main(){
    scanf("%d",&H);
    for (int i = 0,j = 0; i < H; ++i){
      scanf("%d",&j);
      house.push_back(j);
    }
    sort(house.begin(),house.end());
    scanf("%d",&K);
    lo = 0,hi = (int)1e6,mid = (lo+hi)/2;
    while(lo < hi){
        // this hose length works so it's now the upper bound
        if(predicate(mid))
            hi = mid;
        // this hose length is too short
        else              
            lo = mid+1;
        mid = (lo+hi)/2;
    }
    printf("%d\n",mid);
    return 0;
}

Solution for CCC10S4 - Animal Farm

This problem asks of us to find the minimum spanning tree of the graph where the pens are considered the nodes. First we must construct the graph since we are not given the graph required; instead we are given the corners of the pens. This must be done carefully since we need to ensure that any edge that only connects two pens connects these two pens, and any edge connecting one is actually connected this pen with the outside (which is another node in the graph). It is also important to note that it is not always possible that the graph is connected to the outside node (implying the graph is not connected). This is why it will be relatively trivial to use Prim’s algorithm for finding the minimum spanning since Prim’s can detect if a graph is connected or not automatically. Unlike Kruskal’s Algorithm which requires some more legwork (left as an exercise for the reader).

In the provided implementation we the time complexity for constructing the graph is $O(N^2)$ where $N$ is the number of pens, and the time complexity for finding the minimum spanning tree is $O(N^2\log{}N)$.

Time Complexity: $O(N^2\log{}N)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x)(x).begin(),(x).end()
#define x first
#define y second
using namespace std;

struct corners{
    int w,pen1,pen2;
};

const int MAXN = 500,INF = 0x3F3F3F3F;
int N,E;

corners c[MAXN][MAXN];
vector<pair<int,int>>adj[MAXN];
bool v[MAXN];

int prim(int n){
    priority_queue<pair<int,pair<int,int>>>pq;
    int MSTNodes = 1, totWeight = 0;
    for(int i = 0; i < adj[1].size();i++){
        if(adj[1][i].x <= n){
            pq.push(mp(-adj[1][i].y,mp(1,adj[1][i].x)));
        }
    }
    memset(v,false,sizeof v);
    v[1] = true;
    while(MSTNodes < n && !pq.empty()){
        int w = -pq.top().x;
        int sn = pq.top().y.x;
        int en = pq.top().y.y;
        pq.pop();
        if(v[sn] && !v[en]){
            MSTNodes++;
            totWeight+=w;
            v[en] = true;
            for(int i = 0; i < adj[en].size();i++){
                if(adj[en][i].x <= n){
                    pq.push(mp(-adj[en][i].y,mp(en,adj[en][i].x)));
                }
            }
        }
    }
    return MSTNodes == n ? totWeight:INF;
}

int main(){
    scanf("%d",&N);
    for(int i = 0; i < MAXN;i++){
        for(int j = 0; j < MAXN;j++){
            c[i][j].w = c[i][j].pen1 = c[i][j].pen2 = INF;
        }
    }
    for(int i = 0; i < N;i++){
        scanf("%d",&E);
        int tc[E],w[E];
        for(int j = 0; j < E;j++)
            scanf("%d",&tc[j]);
        for(int j = 0; j < E;j++)
            scanf("%d",&w[j]);
        for(int j = 0; j < E;j++){
            int corner[] = {tc[j],tc[(j+1)%E]};
            sort(corner,corner+2);
            if(c[corner[0]][corner[1]].pen1 == INF)
                c[corner[0]][corner[1]].pen1 = i+1;
            else
                c[corner[0]][corner[1]].pen2 = i+1;
            c[corner[0]][corner[1]].w = w[j];
        }
    }
    for(int i = 0; i < MAXN;i++){
        for(int j = 0; j < MAXN;j++){
            // not connected to outside because declared twice
            if(c[i][j].pen1 != INF && c[i][j].pen2 != INF){
                adj[c[i][j].pen1].pb(mp(c[i][j].pen2,c[i][j].w));
                adj[c[i][j].pen2].pb(mp(c[i][j].pen1,c[i][j].w));
            }
            // connected to outside because declared once
            else if(c[i][j].pen1 != INF && c[i][j].pen2 == INF){
                adj[c[i][j].pen1].pb(mp(N+1,c[i][j].w));
                adj[N+1].pb(mp(c[i][j].pen1,c[i][j].w));
            }
        }
    }
    int ans1 = prim(N),ans2 = prim(N+1);
    printf("%d\n",min(ans1,ans2));
    return 0;
}

Solution for CCC10S2P1 - Barking Dogs

This problem asks us to keep track events that come from $D$ dogs, over a time interval $T$. Then we must simulate the problem as specified in the statement. One has to be very careful with how they implement this because this problem is very easy to misinterpret or make silly mistakes.

Time complexity: $O(TD)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
nclude<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define db 1
#define all(x)(x).begin(),(x).end()
#define x first
#define y second
using namespace std;

const int MAXD = 1000;
const int SLEEPING = -1,WAITING = 1,BARKING = 0;
int D,F,T;
int state[MAXD];
int wait[MAXD];
int timer[MAXD];
int cnt[MAXD];
bool v[MAXD];

vector<int>adj[MAXD];

void update(int dog){
   for(int i = 0;i < (int)adj[dog].size();i++){
       if(state[adj[dog][i]] == SLEEPING){
          state[adj[dog][i]] = WAITING;
          timer[adj[dog][i]] = wait[adj[dog][i]];
       }
   }
}
int main(){
    cin >> D;
    for(int i = 0;i < D;i++){
        cin >> wait[i];
    }
    cin >> F;
    for(int i = 0,a,b;i < F;i++){
       cin >> a >> b;
       adj[--a].pb(--b);
    }
    cin >> T;
    memset(state,SLEEPING,sizeof(state));
    memset(timer,SLEEPING,sizeof(timer));
    state[0] = BARKING;
    timer[0] = 0;
    for(int t = 0;t <= T;t++){
       for(int dog = 0;dog < D;dog++){
           if(timer[dog] == 0){
              cnt[dog]++;
              update(dog);
           }
       }
       for(int dog = 0;dog < D;dog++){
           timer[dog]--;
           if(timer[dog] == 0)state[dog] = BARKING;
           if(timer[dog] <  0)state[dog] = SLEEPING;
           if(timer[dog] >  0)state[dog] = WAITING;
       }
    }
    for(int dog = 0;dog < D;dog++)
        cout << cnt[dog] << endl;
    return 0;
}

Solution for CCC10S2P3 - Wowow

This problem asks us to handle a ranking system where we have to update a person’s score and query for the Kth ranked person.

Although this problem was intended to be solved with an offline solution that incorporates a binary indexed tree, today I will go over the solution which uses an order statistic tree. An order statistic tree is special tree that has the same characteristics of a binary search tree, but with the added functionality of being able to query for the Kth ranked element in the tree. The main idea for handling ranked based queries on an ordered statistic tree is to at every node to keep the number of children in its left and right sub-tree. Then when we search through an element every time we go left in the sub-tree we add the value of the current node’s right sub-tree – since the number of elements in the right sub-tree are the number of elements that are larger than the queried element.

In addition to this we also are required to keep the tree balanced otherwise the tree degenerates into a linked list where the time per query is $O(N)$ resulting in an overall complexity of $O(QN)$ instead of $O(Qlog{}N)$. Luckily the built in Ordered Statistics Tree uses a red black tree for its implementation.

Time Complexity: $O(Q\log{}N)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include
#include 
#include 
#define pb push_back
#define mp make_pair
#define db 0
#define all(x)(x).begin(),(x).end()
#define x first
#define y second
using namespace std;
using namespace __gnu_pbds;

typedef tree<
  int,
  null_type,
  greater<int>,
  rb_tree_tag,
  tree_order_statistics_node_update>
set_t;

int N,X,R,K,n;
char cmd;
map<int,int>user,score;
set_t s;

int main(){
    scanf("%d",&N);
    for(int i = 0;i < N;++i){
      scanf(" %c",&cmd);
      if(cmd == 'N'){
        scan(X);
        scan(R);
        user[X] = R;
        score[R] = X;
        s.insert(R);
      }
      else if(cmd == 'M'){
        scanf("%d%d",X,R);
        s.erase(user[X]);
        score.erase(user[X]);
        user[X] = R;
        score[R] = X;
        s.insert(R);
      }else{
        scan(K);
        printf("%d\n",score[*s.find_by_order(K-1)]);
      }
    }
    return 0;
}

Solution for CCC10S2P2 - Tree Pruning

This problem asks us to find the minimum amount of prunes - or sub-trees needed to be removed- to make the difference between the black and white nodes in a tree to be exactly a value D. In-order to accomplish this we must use dynamic programming.

First we must define our dynamic state. In this solution we define the first dimension of our DP array to be the nodes, and the second dimension to be the difference between the black and white nodes in this sub tree, and the value of this index is the minimum amount of prunes required to reach this state.

\[DP[node][B-W] = \text{minimum number of prunes}\]

In-order to fill this DP array we must traverse through the tree and progressively fill the DP array. There are serveral cases that need to be considered when doing this.

Case 0: No prunes are done on this sub tree, so

\[DP[node][\text{left subtree+right subtree+node}] = 0\]

Case 1: One prune is required to make this whole sub-tree equal to 0, so

\[DP[node][0] = 1\]

Case 2: If the current node only has one child then the difference for this subtree are the possible diffrence for this subtree’s one child minus itself so,

\[DP[node][i+type[node]] = min(itself, DP[child][i])\]

Case 3: If the current node has two children the the differences for this subtree are possible differences in its left subtree plus the differences in its right subtree.

\[DP[node][i+j+type[node]] = min(itself, DP[child1][i]+DP[child2][j])\]

Time Complexity : $O(N)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x) (x).begin(),(x).end()
#define f(x) (x)+300
#define x first
#define y second
using namespace std;

const int MAXN = 1000,inf = 0x3f3f3f3f,B = 0,W = 1;
int N,D;
int type[MAXN];
int dp[MAXN][MAXN];
vector<int>adj[MAXN];


int F(int x){
    return x+350;
}

int dfs(int n){
	// left subtree, right subtree
    int tree[2] = {0,0};
    int children = (int)adj[n].size();
    for(int i = 0;i < children;i++){
        tree[i] = dfs(adj[n][i]);
    }
	// the normal tree requires 0 prunes
    dp[n][F(tree[0]+tree[1]+type[n])] = 0;
    // pruning the entire subtree requires 1 prune
    dp[n][F(0)] = 1;
    if(children == 1){
        // dp[n][i+type[n]] = minimum of itself and the dp[child][i]
        // for example dp[0][-300+1] = min(dp[0][-300+1],dp[1][-300])
        // this is because -300+1 = 299
        for(int i = -300;i <= 300;i++)
            dp[n][F(i+type[n])] = min(dp[n][F(i+type[n])],
                                      dp[adj[n][0]][F(i)]);
    }
    else if(children == 2){
        // dp[n][i+type[n]] = min(itself, it's to children which add up to i)
        for(int i = -300;i <= 300;i++) {
            for(int j = -300;j <= 300;j++) {
                // if it's impossible for any branch to reach a sum (i or j)
                // then it's impossible to make i+j
               if(dp[adj[n][0]][F(i)] != inf && dp[adj[n][1]][F(j)] != inf){
                  dp[n][F(i+j+type[n])] = min(dp[n][F(i+j+type[n])],
                                              dp[adj[n][0]][F(i)]
                                              + dp[adj[n][1]][F(j)]);
			   }
			}
		}
    }
	// return the left subtree,right subtree, and itself
    return tree[0]+tree[1]+type[n];
}

int main(){
    scanf("%d%d",&N,&D);
    memset(dp,inf,sizeof(dp));
    for(int i = 0,id,cl,ch;i < N;i++){
        scanf("%d%d%d",&id,&cl,&ch);
        type[id] = (cl == W) ? 1:-1;
        for(int j = 0,nd;j < ch;j++){
            scanf("%d",&nd);
            adj[id].pb(nd);
        }
    }
    dfs(0);
    if(dp[0][F(D)] >= inf)
       printf("-1\n");
    else
       printf("%d\n",dp[0][F(D)]);
    return 0;
}

Solution for CCC10S2P4 - Computer Purchase Return

This problem asks us to build the best computer from a random assortments under a restriced budget. To solve this we must use Dynamic Programming, so the begin we should define our dynamic state. In this case it will be:

\[DP[budget][\text{item number}]\]

Now we iterate over all of the possible combinations and store it in our DP state. However it is important to noitce that $DP[\text{i+cost}][j]$ is only possible if if the previous element $DP[i][j-1]$ is possible.

Time Complexity: $O(TB)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x)(x).begin(),(x).end()
#define x first
#define y second
using namespace std;

const int MAXT = 10,MAXB = 10000;
int T,N,B,best;
int dp[MAXB][MAXT];
vector<pair<int,int>>adj[MAXT];// cost,value

int main(){
   scanf("%d%d",&T,&N);
   memset(dp,0,sizeof(dp));
   for(int i = 0,c,v,t;i < N;++i){
       scanf("%d%d%d",&c,&v,&t);t--;
       adj[t].pb(mp(c,v));
   }
   scanf("%d",&B);
   for(int i = 0;i < (int)adj[0].size();i++){
       dp[adj[0][i].x][0] = max(dp[adj[0][i].x][0],adj[0][i].y);
   }
   for(int t = 1;t < T;t++){
       for(int i = 0;i < (int)adj[t].size();i++){
           for(int j = 0;j <= B;j++){
               if(dp[j][t-1] != 0){
                  dp[j+adj[t][i].x][t] = max(dp[j+adj[t][i].x][t],
                                             dp[j][t-1]+adj[t][i].y);
               }
           }
       }
   }
   for(int i = 0;i <= B;i++){
       best = max(best,dp[i][T-1]);
   }
   printf("%d\n",best == 0 ? -1:best);
   return 0;
}

Solution for CCC10S2P5 - Space Miner

This problem asks us to follow a jagged path created by connecting $N$ points a space ship visits (in sequential order) and to check through our $M$ planets, denoted $M_i$, to see if they are within $D+r_i$ units from any line segment on this path. In-order to solve this we have to use 3D vector mathematics to define each line segment on the path, and a line segment for each planet respective to the path. Then for each segment we should consider the three possible orientations any planet can appear in relative to the path.

Orientation 1: The planet does not fall within the boundaries of the line segment, and its vector projection onto the line segment is opposite to the line segment’s direction, and it’s to the left. In this case the distance is just equal ot the magnitude of the vector formed from the beginning of the line segment to the planet.

Orientation 2: This planet does not fall within the boundaries of the line segment, and its vector projection onto the line segment is opposite to the line segment’s direction, and it’s to the right. In this case the distance is just equal to the magnitude of the vector formed from the end of the line segment ot the planet.

Orientation 3: The planet does fall within the boundaries of the line segment, so its distance is equal to the area of the parallelogram made from the cross product of the line segment and the vector towards the planet divided by the magnitude of the line segment (the base). In the following equation the vector $S$ is the line segment on the path, and $P$ is the vector formed the line segment to the planet $P$.

\[d=\frac{|S*P|}{|S|}\]

Time Complexity: $O(MN)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#include
using namespace std;

struct vector3D{
     double x,y,z;
     vector3D(){
        x = y = z = 0;
     }
     vector3D(double _x,double _y,double _z){
          x = _x,y = _y,z = _z;
     }
     // misceallanous
     double magnitude(){
        return sqrt(x*x+y*y+z*z);
     }
     vector3D unit_vector(){
        return (vector3D){x/this->magnitude(),y/this->magnitude(),
                          z/this->magnitude()};
     }
     // operators
     void operator = (const vector3D&v){
          x = v.x;
          y = v.y;
          z = v.z;
     }
     // vector addition
     vector3D operator + (const vector3D&v){ 
         return (vector3D){x+v.x,y+v.y,z+v.z};
     }
     //vector subtraction
     vector3D operator - (const vector3D&v){
         return (vector3D){x-v.x,y-v.y,z-v.z};
     }
     # vector multiplication
     vector3D operator * (const vector3D&v){
        return (vector3D){y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x};
     }
     // dot product
     double operator ^ (const vector3D&v){
          return x*v.x + y*v.y + z*v.z;
     }

};

struct planet{
   int v,r;
   vector3D p;
   planet(double x,double y, double z,int _v,int _r){
      v = _v, r = _r;
      p = (vector3D){x,y,z};
   }
};

struct gate{
  vector3D p;
  gate(double x,double y, double z){
     p = (vector3D){x,y,z};
  }
};

const int MAXM = 1000;
int M,N,D;
bool vis[MAXM];
vector<planet>planets;
vector<gate>gates;

bool within_range(gate one,gate two,planet pt){
    vector3D v0 = two.p-one.p;
    vector3D v1 = pt.p-one.p;
    vector3D v2 = pt.p-two.p;
    if( (v1 ^ v0) < 0){
       // the projection of the vector lies outside the line segment
       // and counter clockwise to the line segment. So we just take
       // the magnitude of v1
       if(v1.magnitude() <= pt.r+D )
          return true;
       else
          return false;
    }
    if( (v2^v0) > 0){
       // the projection of the vector lies outside the line segment
       // and lockwise to the line segment. So we just take
       // the magnitude of v2
       if(v2.magnitude() <= pt.r+D)
          return true;
       else
         return false;
    }
    // the point is within the boundaries of the vector so we take the 
    // cross product of v0 and v1 to get the area of the parrelogram then
    // we divide it by its base to get the height. Which in this case is 
    // the distance from the line
    if( (v0*v1).magnitude()/v0.magnitude() <= pt.r+D )
        return true;

    return false;
}

int main(){
    cin >> M;
    for(int i = 0;i < M;i++){
        double x,y,z;
        int v,r;
        cin >> x >> y >> z >> v >> r;
        planets.push_back((planet){x,y,z,v,r});
    }
    cin >> N;
    for(int i = 0;i < N;i++){
        double x,y,z;
        cin >> x >> y >> z;
        gates.pb((gate){x,y,z});
    }
    cin >> D;
    int cnt = 0;
    for(int i = 0;i < (int)gates.size()-1;i++){
        for(int j = 0;j < M;j++){
            if(!vis[j] && within_range(gates[i],gates[i+1],planets[j])){
                vis[j] = true;
                cnt += planets[j].v;
            }
        }
    }
    cout << cnt << endl;
    return 0;
}

Solution for CCC11S3 - Alice Through the Looking Glass

This problem asks us to whether or not, given an ordered pair $(x,y)$ and a recursive depth level $M$, if the crystal at this location will be present; meaning it will not be cut off at any point due to the recursive method we generate the crystal. When we do generate this recursively we have to take into consideration the base cases.

Base Cases

By inspection we notice that if $(x,y)$ lies in any part of the crystal the following inequalities must hold:

$$5^{M-1} < x < 5^{M} \,\land\, 0 < y <= 3 \cdot 5^{M-1}$$

Then we note that if $(x,y)$ lies in the left most part of the crystal then the following must hold :

$$5^{M-1} < x < 5^{M} \,\land\, 0 < y <= 5^{M-1}$$

if $(x,y)$ lies in the right most part of the crystal then the following must hold:

$$3\cdot5^{M-1} <= x < 5^{M} \,\land\, 0 < y <= 5^{M-1}$$

Recursive Case

If the current point does lie in the crystal then it must lie within coordinates:

$$(x \mod 5^{M-1}, y \mod 5^{M-1})$$

Time complexity: $O(M)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include
using namespace std;

int m,n,x,y;

bool cryst(int m,int x,int y){
    if(m == 0){
        return false;
    }
    if(x > pow(5,m-1) && x < 5*pow(5,m-1) && y < 3*pow(5,m-1) ){
        //left
        if(x > pow(5,m-1)  && x <= 2*pow(5,m-1) && y <= pow(5,m-1)){
            return true;
        }
        //right
        if(x < 5*pow(5,m-1) && x >= 3*pow(5,m-1) && y <= pow(5,m-1)){
            return true;
        }
        //middle
        if(x > 2*pow(5,m-1) && x < 4*pow(5,m-1) && y <= 2*pow(5,m-1)){
            return true;
        }
        if(cryst(m-1,x%(int)pow(5,m-1),y%(int)pow(5,m-1))){
            return true;
        }
    }
    return false;
}

int main(){
    cin >> n;
    for(int i = 0;i < n;i++){
        cin >> m >> x >> y;
        if(cryst(m,x+1,y+1))
            cout << "crystal" << endl;
        else
            cout << "empty" << endl;
    }
    return 0;
}

Solution for CCC11S5 - Switch

This problem asks us to find the minimum amount of light switches required to make a grid of size $N$, into a grid of turned off lights. Because the bounds on $N$ are relatively small we can represent each light as a bit in an integer using bitmasks. Now that we can easily represent our state all we must do is execute a breadth first search until we find a grid of turned of lights.

Time Complexity: $O(2^N)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include
using namespace std;

int N,ID;
char C;
bool v[(1<<25)+1]; // maximum number of states we have to reach

int main(){
    scanf("%d",&N);
    for(int i = 0;i < N;i++){
        scanf(" %c",&C);
        if(C == '1')
           ID |= 1<<(i);
    }
    queue< pair<int,int> >q;
    q.push(mp(0,ID));
    while(!q.empty()){
        int d = q.front().x;
        int id = q.front().y;
        q.pop();
        for(int i = 0;i < N;i++){
            if(i+3 < N){
                /*Checks for 4 consecutive ones.*/
                if((id >> (i) & 1) 
                && (id >> (i+1) & 1) 
                && (id >> (i+2) & 1)
                && (id >> (i+3) & 1) ){
                     for(int j = i;j < N;j++){
                         if( (id >> (j) & 1) )
                            id ^= 1<<(j);
                         else
                            break;
                     }
                }
            }
        }
        if(id == 0){
            printf("%d\n",d);
            return 0;
        }
        for(int i = 0,bit = 0;i < N;i++){
            bit = (id>>i)&1;
            if(bit == 0 ){
                id ^= 1<<(i);
                if(!v[id]){
                    v[id] = true;
                    q.push(mp(d+1,id));
                }
                id ^= 1<<(i);
            }
        }
    }
    return 0;
}

Solution for CCC11S2P2 - Vampire Tunnels

We are given a weighted graph and our asked to find the minimum amount of time required to reach a node N. This problem requires the use of Dijkstras algorithm with a small change to the algorithm. Since we are given another restriction on the edge weights we add another dimension to our distance array so are distance array is now, and now we just run Dijkstras on this graph.

Time Complexity: $O(N \cdot S \cdot \log(N \cdot S))$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x) (x).begin(),(x).end()
#define x first
#define y second
#define UG 0
#define OG 1
using namespace std;


const int MAXN = 1601, MAXSL = 3601,INF = 0x3F3F3F3F;
int S,N,E,ans = INF,tans;
vector< pair<int,pair<int,int> > > adj[MAXN]; // city, distance, sunlight
int dist[MAXN][MAXSL];


void dijkstra(){
    priority_queue< pair<int,pair<int,int> > >pq;
    pq.push(mp(0,mp(0,0)));
    while(!pq.empty()){
        int d  =  -(pq.top().x);
        int sl =  -(pq.top().y.x);
        int n  =    pq.top().y.y;
        pq.pop();
        for(int i = 0;i < (int)adj[n].size();++i){
            int nt = adj[n][i].x;
            int w  = adj[n][i].y.x;
            int type = adj[n][i].y.y;
            if(type == UG){
                if(dist[nt][sl] > d+w){
                    dist[nt][sl] = d+w;
                    pq.push(mp(-dist[nt][sl],mp(-sl,nt)));
                }
            }
            else if(type == OG){
                if(sl + w <= S){
                    if(dist[nt][sl] > d+w){
                        dist[nt][sl] = d+w;
                        pq.push(mp(-dist[nt][sl],mp(-(sl+w),nt)));
                    }
                }
            }
        }
    }
}
int main(){
    memset(dist,INF,sizeof(dist));
    scanf("%d%d%d",&S,&N,&E);N--,E--;
    for(int i = 0,s,t,d,u; i <= E;++i){
        scanf("%d%d%d%d",&s,&t,&d,&u);
        adj[s].pb(mp(t,mp(d,u)));
        adj[t].pb(mp(s,mp(d,u)));
    }
    dijkstra();
    for(int i = 0; i <= S;++i)
        ans = min(ans,dist[N][i]);
    if(ans == INF)
        ans = -1;
    printf("%d\n",ans);
    return 0;
}

Solution for CCC11S2P3 - Reorganization

We are given a list of people and are asked whether or not it is possible to match an employee with a high rank with 0-2 employees with lower ranks. This can be accomplished by greedily matching an employee with an employee closest in rank, but which is still higher than its own rank. When there are no possible employees to match with then we simply print out “No”. Otherwise if the process is able to finish we print “Yes”.

Time Complexity: $O(N \cdot \log(N))$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x) (x).begin(),(x).end()
#define x first
#define y second
#define nullptr 0
using namespace std;


int N;
set<int>v;
map<int,int>C;

int main(){
    cin >> N;
    for(int i = 0,j = 0;i < N;i++){
       cin >> j;
       if(i == 0)
          v.insert(j);
       else{
          set<int>::iterator it = --v.upper_bound(j);
          if(*v.begin() > j){
             printf("NO\n");
             return 0;
          }
          while(it != v.end()){
            if(C[*it] < 2){
               C[*it]++;
               v.insert(j);
               if(C[*it] == 2)
                  v.erase(it);
               break;
            }
            --it;
          }
          if(!v.count(j)){
             printf("NO\n");
             return 0;
          }
       }
    }
    printf("YES\n");
    return 0;
}

Solution for CCC11S2P3 - Spies Like Us

We are given a list of N people who wish to speak with each other, we then want to find whether a person shares more than one common contact with another person. This can be done by brute forcing the through all of the contact lists M and keeping track of how many common contacts people share.

Time Complexity: $O(N^2 \cdot M)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x) (x).begin(),(x).end()
#define x first
#define y second
using namespace std;

const int MAXN = 2000;
int N,M,K;
int  cnt[MAXN][MAXN];
bool mtx[MAXN][MAXN];
vector<int>adj[MAXN];

int main(){
    scanf("%d%d%d",&N,&M,&K);
    for(int i = 0,a,b;i < K;i++){
        scanf("%d%d",&a,&b);
        adj[--a].pb(--b);
        mtx[a][b] = true;
    }
    for(int i = 0;i < N;i++){
        for(int j = 0;j < (int)adj[i].size();j++){
            for(int k = 0;k < N;k++){
                if(i!=k && mtx[k][adj[i][j]]){
                   cnt[i][k]++;
                   if(cnt[i][k] > 1){
                      printf("NO\n");
                      return 0;
                   }
                }
            }
        }
    }
    printf("YES\n");
    return 0;
}

Solution for CCC12S4 - A Coin Game

This problem asks us to keep track of a game and finding the minimum amount of moves required to make a certain grid into ascending order. This problem can be done by executing a breadth first search and using a set to represent the current game. From then one we keep on creating a grid until we reach our desired grid.

Time Complexity:

If we assume without loss of generality that we can place numbers on top of each other, without the restrictions, then we can reduce the sample space we are searching to the number of combinations in the stars and bars problem. From this we can see that a nice upper bound can be $O((n+k-1)C(n))$ where k = n meaning we have $O((2n-1)C(n))$ which is roughly O((2n) C (n) ), and using stirlings approximation we see that this is $O(2^n)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x)(x).begin(),(x).end()
#define MAXN 8
#define reset_game(G,M) for(int i = 0; i < N;i++)G[i].clear();
using namespace std;

struct state{
    vector<int>g[MAXN];
    int d;
    string id;
};

int N,ai;
vector<int>game[MAXN];
set< string >past_game;


string to_s(int x){
    stringstream ss;
    string ret;
    ss << x;
    ss >> ret;
    return ret;
}

string to_id(vector<int>g[MAXN]){
    string id;
    for(int i = 0; i < MAXN;i++){
        string t;
        for(int j = 0; j < (int)g[i].size();j++){
            t+= to_s(g[i][j]);
        }
        t+="-";
        id+=t;
    }
    return id;
}
bool game_done(vector<int>g[MAXN]){
    for(int i = 0; i < N;i++)
        if(g[i].empty())
            return false;
    for(int i = 0; i < N;i++)
        if(g[i].size()!= 1 || g[i][0] != i+1)
            return false;
    return true;
}
void print_game(vector<int>g[MAXN],int d,string id){
    printf("D:%d ;",d);cout << id << endl;
    for(int i = 0; i < MAXN;i++){
        printf("%d:",i+1);
        for(int j = 0; j < (int)g[i].size();j++)
            printf("%d",g[i][j]);
        printf("\n");
    }
    printf("\n");
}
int bfs(){
    queue<state> q;
    q.push( (state){game[0],game[1],game[2],
                    game[3],game[4],game[5],
                    game[6],game[7],0,
                    to_id(game)});
    while(!q.empty()){
        vector<int>g[MAXN] = q.front().g;
        int d = q.front().d;
        string id = q.front().id;
        q.pop();
        if(past_game.find(id) != past_game.end())
            continue;
        else
            past_game.insert(id);
        //print_game(g,d,id);
        if(game_done(g)){
            return d;
        }
        for(int i = 0; i < N;i++){
            if(g[i].empty())
                continue;
            if(i-1>=0){
                int left_end = g[i-1].size()-1;
                int curr_end = g[i].size()-1;
                if(g[i-1].empty()){
                    g[i-1].push_back(g[i][curr_end]);
                    g[i].erase(g[i].begin() + curr_end);
                    q.push( (state){g[0],g[1],g[2],
                                    g[3],g[4],g[5],
                                    g[6],g[7],d+1,
                                    to_id(g)});
                    left_end++;curr_end--;
                    g[i].push_back(g[i-1][left_end]);
                    g[i-1].erase(g[i-1].begin()+left_end);
                }
                else if(g[i-1][left_end] > g[i][curr_end]){
                    g[i-1].push_back(g[i][curr_end]);
                    g[i].erase(g[i].begin() + curr_end);
                    q.push( (state){g[0],g[1],g[2],
                                    g[3],g[4],g[5],
                                    g[6],g[7],d+1,
                                    to_id(g)});
                    left_end++;curr_end--;
                    g[i].push_back(g[i-1][left_end]);
                    g[i-1].erase(g[i-1].begin()+left_end);
                }
            }
            if(i+1<N){
                int rght_end = g[i+1].size()-1;
                int curr_end = g[i].size()-1;
                if(g[i+1].empty()){
                    g[i+1].push_back(g[i][curr_end]);
                    g[i].erase(g[i].begin() + curr_end);
                    q.push( (state){g[0],g[1],g[2],
                                    g[3],g[4],g[5],
                                    g[6],g[7],d+1,
                                    to_id(g)});
                    rght_end++;curr_end--;
                    g[i].push_back(g[i+1][rght_end]);
                    g[i+1].erase(g[i+1].begin()+rght_end);
                }
                else if(g[i+1][rght_end] > g[i][curr_end]){
                    g[i+1].push_back(g[i][curr_end]);
                    g[i].erase(g[i].begin() + curr_end);
                    q.push( (state){g[0],g[1],g[2],
                                    g[3],g[4],g[5],
                                    g[6],g[7],d+1,
                                    to_id(g)});
                    rght_end++;curr_end--;
                    g[i].push_back(g[i+1][rght_end]);
                    g[i+1].erase(g[i+1].begin()+rght_end);
                }
            }
        }
    }
    return -1;
}
int main(){
    while(scanf("%d",&N)&& N!= 0){
        for(int i = 0; i < N;i++){
            scanf("%d",&ai);
            game[i].push_back(ai);
        }
        //print_game(game,0,to_id(game));
        int ans = bfs();
        if(ans == -1)printf("IMPOSSIBLE\n");
        else         printf("%d\n",ans);
        past_game.clear();
        reset_game(game,MAXN);
    }
    return 0;
}

Solution for CCC12S2P2 - The Hungary Games

This problem asks us to find the second shortest path in a graph. This can be done using either Dijkstra’s algorithm or the shortest path faster algorithm, with a small change. This change being that instead of holding the minimum distance to a node, we keep the two smallest distances to a node.

Time Complexity: $O(E+V)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x)(x).begin(),(x).end()
#define x x
#define y y
using namespace std;

const int MAXN = 2*(int)1e4 + 5, INF = 0x3F3F3F3F;
int N,M,dist[MAXN][2];
vector< pair<int,int> > adj[MAXN];// city, weight

void spfa(){
    queue< pair<int,int> >q;
    q.push(mp(0,1));
    while(!q.empty()){
        int n = q.front().y;
        int d = q.front().x;
        q.pop();
        for(int i = 0; i < (int)adj[n].size();++i){
            if(dist[adj[n][i].x][0] > d + adj[n][i].y){
                dist[adj[n][i].x][1] = dist[adj[n][i].x][0];
                dist[adj[n][i].x][0] = d+adj[n][i].y;
                q.push(mp(d+adj[n][i].y,adj[n][i].x));
            }
            else if(dist[adj[n][i].x][0] != d + adj[n][i].y 
                    && dist[adj[n][i].x][1] > d + adj[n][i].y){
                dist[adj[n][i].x][1] = d+adj[n][i].y;
                q.push(mp(d+adj[n][i].y,adj[n][i].x));
            }
        }
    }
}

int main(){
    memset(dist,INF,sizeof(dist));
    scanf("%d%d",&N,&M);
    for(int i = 0,a,b,l; i < M;++i){
        scanf("%d%d%d",&a,&b,&l);
        adj[a].pb(mp(b,l));
    }
    spfa();
    printf("%d\n",(dist[N][1] != INF) ? dist[N][1]:-1);
    return 0;
}

Solution for CCC12S2P3 - Mhocksian Languages

This problem asks us if a given word can be created using a set of rules. This can be done by setting a dynamic programming state where each states represents a link between variable and a certain word. Once we have set our state we can use recursion and memorization to check if a word is possible.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define db 0
using namespace std;

int V,T,R,W;
vector<string>var;
map<string,vector<string> >rules;
map<string,map<string,bool> >path;
string a,b,c;


bool possible(string word,string var){
     if(path[var].count(word))
        return path[var][word];
     else{
        for(int i = 1;i < (int)word.length();i++){
            string w1 = word.substr(0,i);
            string w2 = word.substr(i,-1);
            for(int j = 0;j < (int)rules[var].size();j++){
                string v1; v1 += rules[var][j][0];
                string v2; v2 += rules[var][j][1];
                if(possible(w1,v1) && possible(w2,v2)){
                   path[var][word] = true;
                   return true;
                }
            }
        }
         path[var][word] = false;
         return false;
     }
}

int main(){
  cin >> V >> T;
  for(int i = 0;i < V;++i){
    cin >> a;
    if(i == 0)// we only care about the first element
       var.pb(a);
  }
  for(int i = 0;i < T;++i){
    cin >> a;
    // we don't care about these
  }
  cin >> R;
  for(int i = 0;i < R;++i){
    cin >> a >> b;
    path[a][b] = true;
  }
  cin >> R;
  for(int i = 0;i < R;++i){
    cin >> a >> b >> c;
    rules[a].pb(b+c);
  }
  cin >> W;
  for(int i = 0;i < W;++i){
      cin >> a;
      if(possible(a,var[0]))
         cout << 1 << endl;
      else
         cout << 0 << endl;
  }
  return 0;
}

Solution for CCC13S2P2 - Tourney

This problem asks us to keep track of an ongoing competition and support three queries:

1) Updating a person’s skill

2) Finding the number of people a person win’s against

3) Who won the competition

All of these queries can be solved using two segment trees, the first segment tree represents who won each round of the competition and the second segment tree represents the number of wins each individual had.

Time Complexity: $O(N + Q\log{N})$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x)(x).begin(),(x).end()
#define x first
#define y second
using namespace std;

const int MAXN = (1<<20)+5,inf = 0x3f3f3f3f;
int N,M,I,S,qlo,qhi,idx;
int arr[MAXN],best[4*MAXN],tree[4*MAXN];
char cmd;
map<int,int>score_to_index;

int query(int n,int lo,int hi){
    if(lo > hi || lo > qhi || hi < qlo)
       return -inf;
    else if(lo >= qlo && hi <= qhi)
       return tree[n];
    else
       return max(query(2*n,lo,(lo+hi)/2),query(2*n+1,(lo+hi)/2+1,hi));
}
int query2(int n,int lo,int hi){
    if(lo > hi || lo > qhi || hi < qlo)
       return 0;
    else if(tree[n] == arr[idx])
       return best[n];
    else
       return max(query2(2*n,lo,(lo+hi)/2) , query2(2*n+1,(lo+hi)/2+1,hi));
}
void update(int n,int lo,int hi){
    if(idx >= lo && idx <= hi){
       if(lo == hi)
          tree[n] = arr[lo];
       else{
          update(2*n,lo,(lo+hi)/2);
          update(2*n+1,(lo+hi)/2+1,hi);
          tree[n] = max(tree[2*n],tree[2*n+1]);
          best[n] = max(best[2*n],best[2*n+1]) + 1;
       }
    }
}

int main(){
    memset(tree,-inf,sizeof(tree));
    scanf("%d%d",&N,&M);N = (1<<N);
    for(int i = 1;i <= N;++i){
        scanf("%d",&arr[i]);
        idx = i;
        score_to_index[arr[i]] = i;
        update(1,1,N);
    }
    for(int i = 1;i <= M;++i){
        scanf(" %c",&cmd);
        if(cmd == 'R'){
          scanf("%d%d",&I,&S);
          score_to_index[S] = I;
          arr[I] = S;
          qlo = qhi = idx = I;
          update(1,1,N);
        }
        if(cmd == 'W'){
          qlo = 1,qhi = N;
          printf("%d\n",score_to_index[query(1,1,N)]);
        }
        if(cmd == 'S'){
          scanf("%d",&I);
          idx = qlo = qhi = I;
          printf("%d\n",query2(1,1,N));
        }
    }
    return 0;
}

Solution for CCC13S2P3 - LHC

This problem asks us to find the diameter of a tree and to find how many times this diameter appears in the tree. We can find the diameter of the tree by using two breadth first searches. The key observation to make is that for every diameter in the tree it must always pass through one common node. This node be can found using by traversing $diamater/2$ nodes back from the last node in a diameter. Once this central node is found we can divide the problem into two cases:

1) The diameter of the tree is odd

2) The diameter of the tree is even

In the case where the diameter of the tree is odd we can prove that all of sub-trees of importance from this central node must be even in height. This is because since the diameter is odd is consists of one node (the central node) and two even branches of equal height. Through this observation we can then determine the amount of diameters that can be made by checking each sub-tree from the central node and doing some arithmetic and reasoning. In the case where the diameter of the tree is odd we can prove that there will always be one branch from the central node that is the longest. Then we know we just have to multiply the occurrences of this one branch to the occurrences of the next biggest branch from the central node.

Time Complexity: $O(E + V)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include
#define pb push_back
#define mp make_pair
#define db 0
#define all(x)(x).begin(),(x).end()
#define x first
#define y second
#define LL long long
using namespace std;

const int MAXN = 400000;
int N;
int tree[MAXN][2];
int parent[MAXN];
bool v[MAXN];
vector<int>adj[MAXN];


void reset(){
    for(int i = 0;i < MAXN;i++){
        parent[i] = i;
        v[i] = false;
    }
}
pair<int,int> bfs(int u){
    queue< pair<int,int> >q;
    pair<int,int>fn = mp(0,0);
    q.push(mp(u,1));
    reset();
    v[u] = true;
    while(!q.empty()){
       int n = q.front().x;
       int d = q.front().y;
       q.pop();
       if(d > fn.y)
          fn.x = n,fn.y = d;
       for(int i = 0;i < (int)adj[n].size();i++){
          if(!v[adj[n][i]]){
             parent[adj[n][i]] = n;
             v[adj[n][i]]      = true;
             q.push(mp(adj[n][i],d+1));
           }
       }
    }
    return fn;
}
void dfs(int n){
      tree[n][0] = 1;
      tree[n][1] = 0;
      v[n] = true;
      for(int i = 0;i < (int)adj[n].size();i++){
          if(!v[adj[n][i]]){
            dfs(adj[n][i]);
            if(tree[adj[n][i]][1]  > tree[n][1]){
               tree[n][0] = tree[adj[n][i]][0];
               tree[n][1] = tree[adj[n][i]][1];
            }
            else if(tree[adj[n][i]][1] == tree[n][1])
               tree[n][0] += tree[adj[n][i]][0];
         }
      }
      tree[n][1] += 1;
}

int main(){
    scanf("%d",&N);N--;
    int sn = 0;
    for(int i = 0,a,b;i < N;i++){
        scanf("%d%d",&a,&b);
        adj[--a].pb(--b);
        adj[b].pb(a);
        if(i == 0)sn = a;
    }
    // bfs from one node
    pair<int,int> ln1 = bfs(sn);
    // bfs from farthest node
    pair<int,int> ln2 = bfs(ln1.x);
    if(ln2.y%2 != 0){// the diameter of the tree is odd
       LL longest_path = ln2.y, occurences = 0;
       int back_track = ln2.y/2;
       while(back_track--){// backtrack to the central node
           ln2.x = parent[ln2.x];
       }
       // now dfs from the central node
       reset();
       dfs(ln2.x);
       LL best[2];
       best[0] = tree[ln2.x][0];
       best[1] = tree[ln2.x][1]-1;
       for(int i = 0;i < (int)adj[ln2.x].size();i++){
           if(tree[ adj[ln2.x][i] ][1] == best[1]){
              occurences+= tree[adj[ln2.x][i]][0]*(best[0]-tree[adj[ln2.x][i]][0]);
              best[0]-=tree[adj[ln2.x][i]][0];
           }
       }
       printf("%lld %lld\n",longest_path,occurences);

    }else{// the diamater of the tree is even
       LL longest_path = ln2.y, occurences = 0;
       int back_track = ln2.y/2;
       while(back_track--){// backtrack to the central node
           ln2.x = parent[ln2.x];
       }
       reset();
       dfs(ln2.x);// find the subtrees
       LL best[2][2]= { {0,0},{0,0}};
       for(int i = 0;i < (int)adj[ln2.x].size();i++){
           if(tree[adj[ln2.x][i]][1] > best[0][1]){ // there is only one subtree of maximal length
              best[0][1] = tree[adj[ln2.x][i]][1];
              best[0][0] = tree[adj[ln2.x][i]][0];
           }
           else if(tree[adj[ln2.x][i]][1] > best[1][1]){// there are other trees of smaller length
              best[1][1] = tree[adj[ln2.x][i]][1];
              best[1][0] = tree[adj[ln2.x][i]][0];
           }
           else if(tree[adj[ln2.x][i]][1] == best[1][1])// we add up the trees of the same length
              best[1][0] += tree[adj[ln2.x][i]][0];
       }
       occurences = best[0][0]*best[1][0];
       printf("%lld %lld\n",longest_path,occurences);
    }
    return 0;
}

Solution for CCC14S4 - Tinted Glass Windows

This problem asks to find the area for the union of rectangles, if and only if the area in the union of rectangles is greater than or equal to a specified value T. This can be done using a line sweep algorithm. The main idea for the line sweep algorithm shown is that we create vertical line segments for beginning and ending of each rectangle. Once this is done we sort these segments and traverse them in order from lowest x coordinate to the highest.

Time Complexity: $O(N^{2} \log{N})$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include
#define pb push_back
#define mp make_pair
#define db 1
#define lb(x) ((x)&(-x))
#define all(x) (x).begin(),(x).end()
#define needforspeed ios::sync_with_stdio(0);cin.tie(0)
#define endl '\n'
#define pb push_back
#define mp make_pair
#define LL long long
using namespace std;


struct line{
    int x,id;
    int y1,y2;
    int tint,type;
    line(int _x,int _y1,int _y2,int _tint,int _id, int _type){
        x = _x;
        y1 = _y1,y2 = _y2;
        id = _id,tint = _tint, type = _type;
    }
    bool operator < (const line&rht)const{
       return x == rht.x ? type < rht.type:x < rht.x;
    }
};
struct point{
   int y,id;
   int tint,type;
   point(int _y,int _id,int _tint,int _type){
         y = _y,id = _id;
         tint = _tint, type = _type;
   }
   bool operator < (const point&rht)const{
       return y == rht.y ? type < rht.type:y < rht.y;
    }
};


const int START = 1,END = -1;
int N,T;
LL ANS;
vector<line> segments;

int main(){
    needforspeed;
    cin >> N >> T;
    for(int i = 0,x1,y1,x2,y2,t,id = 0;i < N;i++){
        cin >> x1 >> y1 >> x2 >> y2 >> t;
        segments.pb( (line){x1,y1,y2,t,id,START});
        segments.pb( (line){x2,y1,y2,t,id,END});
        id++;
    }
    sort(all(segments));
    vector<point>y_axis;
    for(int i = 0;i < (int)segments.size();i++){
       if(i > 0){
          LL delta_x = abs(segments[i].x-segments[i-1].x);
          LL ctint = 0,delta_y = 0;
          for(int j = 0;j < (int)y_axis.size();j++){
              if(j > 0){
                delta_y = y_axis[j].y - y_axis[j-1].y;
                if(ctint >= T)
                   ANS += delta_x*delta_y;

                if(y_axis[j].type == START)
                   ctint += y_axis[j].tint;
                else
                   ctint -= y_axis[j].tint;
              }
              else
                 ctint+=y_axis[j].tint;

          }
          if(segments[i].type == START){
             y_axis.pb((point){segments[i].y1,segments[i].id,segments[i].tint,START});
             y_axis.pb((point){segments[i].y2,segments[i].id,segments[i].tint,END});
             sort(all(y_axis));
          }
          if(segments[i].type == END){
             for(int j = 0;j < (int)y_axis.size();j++){
                 if(segments[i].id == y_axis[j].id){
                    y_axis.erase(y_axis.begin()+j);
                    j--;
                 }
             }
          }
       }
       else{
         y_axis.pb((point){segments[i].y1,segments[i].id,segments[i].tint,START});
         y_axis.pb((point){segments[i].y2,segments[i].id,segments[i].tint,END});
         sort(all(y_axis));
       }
    }
    cout << ANS << endl;
    return 0;
}

Open Source in the Enterprise

2019-08-14T00:00:00+00:00

Abstract

Open source has been gaining lots of steam in recent years. Several enterprise companies are adopting these “open source” projects (where source code is free for use, modification and distribution) and advocating for contributions to these projects. But do these projects pose a threat to our safety? While some projects are backed by major corporations, others can be maintained by unidentified developers who hold zero liability for issues in their code. Here we will look to discuss the benefits open source has on the enterprise and examine the common concerns related to open source software.

Introduction

In recent years, open source software has seen greater adoption rates by enterprise companies. Companies that build in-house tools are now deciding to open source portions of their tools to the community for consumption and collaboration. Lots of companies are now openly advertising their open source initiatives to gain favors in the tech community. It wasn’t always like this; historically many enterprise companies were revolted by the idea of open source software. Most notably, in 2003 Microsoft CEO Steve Balmer (a notably anti-open source personality) said, “In the end, there’s no one to be held accountable for flawed software in an open-source model.” (Pennington, 2018). This stance was held firm in Microsoft for 15 years until the new CEO, Satya Mandela, changed the company direction drastically. It is now a big advocate for open source, to the extent that Microsoft is now one of the biggest contributors to open source in terms of active developers (Asay, 2018). These are contradicting perspectives on the topic, which raises the following questions: what benefits do companies get from open source software, and what benefits do companies get from open sourcing their tools? What has changed in the past decade with open source that has sparked this interest, and should companies be adopting open source (i.e., is it safe for consumption)? These are all important questions that need to be answered to determine the relevancy of open source software in today’s industry.

Benefits of Open Source Software

One of the main advantages of open source software is the speed it brings to development due to its inherent culture for code reuse. This can range from command line tools which help with analysis or deployment of software, all the way down to GUI components incorporated in the websites we see today. Developers are encouraged to share their solutions, and if they can’t find a solution to their specific use case, to improve an existing solution and share that with the community. This collaboration has created a lot of useful open source software that’s used in industry today. With this widespread availability of software, it has encouraged the “move fast and break things” mindset coined by Facebook. Being able to shop code quickly has made companies like Facebook flourish as they go through many prototypes while receiving constant user feedback. Hiring Perspective of Open Source

Public Opinion from Developers of Open Source

A recent 2019 survey on StackOverflow shows that 65% of professional developers on their platform contribute to open source software (Stackoverflow, 2019). Furthermore, a former head of the open source program at Facebook (James Pearce) released survey results stating that about 2/3 of their software developers were aware about the company’s open source efforts and said that it positively contributed to their decision to work for them (DeCausemaker, 2014). So, it is clear from this that developers appreciate open source culture.

Many companies are now following suit by releasing tools which are open sourced like React (from Facebook), Docker (from dotcloud), and VS Code (from Microsoft). These projects now have hundreds of active contributors, a sizable portion of whom aren’t developers that have already been hired from the company. A 2018 report held in partnership with The Linux Foundation and Dice found that hiring open source talent is a priority for 83% of hiring managers from these tech companies; this was taken from a sample size of 750+ hiring managers (The Linux Foundation , 2018). This is advantageous for companies since they can focus fewer resources on hiring developers and, if needed, provides them a proven talent pool from which they can attempt to hire. Recruiting from Open Source

GitHub is an extremely popular “social coding” playground for developers. Several of the famous open source tools previously mentioned and more are all hosted on this website. So, what better place to look for great developers then the place they hang out? A study done on employers showed that candidates can give a good impression to HR managers through contributions to these popular projects; they treat these contributions as a seal of approval from the developer community that the candidate can write good code (Marlow, 2013). From the sample in this study, they also believed that these were better indicators than reading a resume, since they are able to evaluate soft skills in addition to hard skills by seeing a candidate’s activity regarding managing other people and contributions to their own projects. So, this is a very valid way for people to do recruiting.

From this, we can tell that enterprise companies that decide to participate in the open source culture will have additional resources when it comes to hiring developers.

Profitability in Open Source

Clearly, the open source culture provides companies a numbers advantage when it comes to maintaining projects, but where’s the monetary value in this? Initially, people would be quick to think that companies are losing their profit capability when they give up their copyrights. However, there are multiple companies that seem to have thrived in the open source space and are doing extremely well today.

Case study of Elastic Search

Elastic Search is a famous company which started in 2010 with the release of their ELK (Elastic Logstash Kibana) stack tools. They incorporated existing open source tools like Lucene and Logstash into Elastic Search so they could be able to aggregate and search information from systems. They are a prime example of an open source company that is finding success in the open source space. Their business model revolves around offering enterprise support and solutions on top of their existing open source solution. Elastic Search’s most recent earnings unofficial audit showed that they had a FY19 Revenue of $261.5 million with 1442 employees in over 35 countries worldwide (Elastic Search, 2019).

Case study of Red Hat

Red Hat is a famous company founded in 1993, being the world’s leading provider in enterprise open source solutions. They are the creators of the popular RHEL (Red Hat Enterprise Linux) system, which is used worldwide in several companies’ servers due to its robustness and support. They also manage cloud services like OpenShift and Ansible that help with scaling organizations’ software to the enterprise level (e.g., the likes of Google and Facebook). They are another prime example of an open source company that has found success in open source. Their business model also revolves around offering enterprise support and solutions on top of their existing open source solution. Red Hat’s most recent earnings unofficial audit showed that they had a FY19 Revenue of $3.4 billion (RedHat, 2019). So, it’s quite evident that open sourcing software can still be quite profitable for some companies which go down this route.

Now what should companies that don’t have the same freedom as these open source companies be concerned about when incorporating open source into their products. While the above companies do give enterprise support for some critical software suites, they cannot possibly provide support on all of the open source projects out there. For many of these projects contributions are coming from developers who have zero liability for their work, and who don’t have an incentive to support this for the enterprise, for free. Does this make Steve Balmer’s earlier quote worrying for enterprise adoption? Let’s find out! Considerations for Open Source Software

Legal adoption – Open Source Licensing

If you’re planning on incorporating open source software into your company, the first thing that should come to mind is the copyright terms for these projects. Thankfully this has all been thought out in the past with the release of several open source licenses for company needs. The popular source code management website GitHub had a survey on open source license usage, finding that, overall, about 20% of the projects have a license, and that the clear favourite copyleft licenses were: MIT, GPLv2/3, and Apache. With their usage combined to be about 77.2% of the total licenced projects (Balter, 2015). This is great for companies, since they only have to follow the rules set out by these licenses to begin incorporating them into their work.

Copyleft Licenses

Copyleft licenses are in a sense the opposite of copyright licences. Whereas copyright restricts the freedom to use, modify, and enhance a product to one sole user, copyleft guarantees the four essential freedoms for free software: freedom to run the program as you wish for any purpose, freedom to study the program and change it as you wish, freedom to redistribute the program to help others, and the freedom to distribute copies of your modified versions to others. Any software that possesses the four freedoms above is considered libre software, coined by Richard Stallman (Free Software Foundation, 2019). All of the open source licenses have aspects that fall under these categories, however, depending on the looseness of the copyright, some may give you less rights than others.

Weak Copyleft Licenses

Weak copyleft licenses really only require users of the software to give credit to the developer or organization by including the license in whatever piece of code that was written by the project. Everyone can essentially use these licenses without having to worry about copyright practices regarding the usage of the software, and it is indeed free to use. The following are licenses that fall under this category: MIT, BSD, Apache, LGPL. These are great for most enterprise companies because they can freely use and modify the software as they deem fit. Visual Studio Code is an example of a project with a weak copyleft license (MIT) with some additional license terms that make it not libre software.

Strong Copyleft Licenses

These are licences that gives you all of the four freedoms mentioned earlier. They are the following: GPLv2, GPLv3, AGPLv3. These licences are special in the fact that any software that uses them must also be sublicensed as GPL licences. There are some minor changes between the GPLv2 and GPLv3, mainly being is more friendly with other licenses, and it has more clarity along the lines of whether you have to disclose the source code if the software is provided over a network. The AGPLv3 however is the special case that makes so that users who use this product over a network must have access to the source code. These types of licences are generally considered threats for the enterprise due to their viral nature when incorporating them with other works.

Companies need to be vigilant of their licence usage since breaking the terms of service for these GPL can results in major fines from the FSF (Free Software Foundation). There has been several documented cases of companies being sued for misusing GPL licenced software, one of the earlier recorded cases was in 2007 where the company Busybox was suing Westinghouse Digital Electronics for using their GPLv2 licences software on their embedded televisions, and selling it to customers under a new licence that is incompatible with the GPLv2. The damages were $90,000 in total and Busybox won the case (Timmer, 2010).

If you’re planning on incorporating work from these libraries into the enterprise then the obvious choice is to only use weak copyleft licences, since strong copyleft licences pose a potential threat to your companies’ intellectual property.

Security of Open Source Software

Many of the components in the software we use daily may be open sourced, take note of the television example from earlier, it’s really easy to incorporate these projects into products. But this begins to become a problem when these components pose a threat to your security. Some of these open source codebases can be extremely large like the Linux Kernel which now houses 25 million lines of code (Larabel, 2018). These codebases can’t reasonably be manually analyzed for vulnerabilities by a small team of developers, many companies will have to rely on automated or crowd sourcing efforts. And there’s still the question of whether closed source software is more secure than open source software that needs to be answered. .

Security: Open Source vs Closed Source

The main argument against open source software being secure, is its lack of security through obscurity. Attackers can easily identify vulnerabilities and abuse it since the source code is open to the public. A recent study concluded that in the long run open source software will be more secure, while closed source software will provide a bigger disadvantage to the defender (Hoepman, 2018). This is because open source software will likely have a spike in beginning as vulnerabilities become public, but as time goes on these vulnerabilities will be patched quickly, thus releasing the vulnerability period. This is not the case with closed source software since more often than not the vulnerabilities will be abused for an extended amount of time before it is identified and patched. This is a result of Linus’s Law: “Given enough eyeballs, bugs are shallow” which simply put is that given enough beta testers and co-developers almost any problem will be identified quickly and fixed accordingly (Raymond, 2000). This same article also provides a real-life example where portions of Microsoft’s Windows NT became public and within days the first exploit was published.

This form of security through collaboration will likely make open source software more secure in the long as security vulnerabilities are identified to developers patched promptly by developers.

Auditing techniques for Open Source Software

As mentioned before, with the ever-increasing complexity of projects developers will need a better way to audit this code before consumption. The solution to this is automation or crowd sourcing. Depending on the platform the software is targeting there are a wide variety of tools available for detection of security issues.

Static Code Analyzers

If you’re developing standalone applications that primarily run on the Linux servers there are a mix of static analyzers like BOON, CQual, and RATS which can help for detecting buffer overflows, inconsistent usage of values, and general inspection of programs for security vulnerabilities. The issue with these tools is that they have a requirement of several hours to analyze modestly sized programs, which isn’t reasonable when you’re trying to moderate code with millions of lines (Cowan, 2003).

Cloud based solutions

If you’re developing applications with cloud computing capabilities, then you will likely want to deal with tools at the network level. There are a wide variety of tools that help with information gathering, scanning, exploitation, and forensic analysis. Examples are Netcraft (Anti-fraud and Anti Phishing), Nessus (exploits vulnerabilities in system confirmation), Wireshark (network sniffing and monitoring infrastructure tool), and Aqua Scan (docker container risk assessment) (Almatari, 2018). These tools can be very helpful for identifying vulnerabilities in software that you incorporate in your tools before you deploy them to production which can help avoid common abusable issues.

Crowd sourcing

While many of the automated solutions are great, they mostly have their short comings in terms of performance. A very useful alternative is to crowd source bug finds, this can be accomplished through websites like GitHub. This platform now has a crowd sourcing tools which allow them to alert projects on their platform about vulnerable open source modules they have incorporated (Han, 2017). This feature is extremely helpful for reducing the vulnerability period for several projects, allowing them to either remove the affected module to update to the latest version which likely has a security patch.

From this we can infer that there appears to be a wide variety of tools and crowd sourcing resources available for auditing software. These resources can easily be used to audit open source software and keep the user in the loop for security vulnerabilities that may arise from usage of these open source software projects.

Closing Remarks

Open source software seems to have many advantages for enterprise companies. They can greatly benefit from opportunities in hiring and overall business models. There has been a detailed overview on the legal aspects of incorporating open source software into the enterprise, and the rules companies have to abide by to not get into trouble. We have also discussed the main argument against open source software being secure and found that open source software is actually more secure in the long run. Enterprise companies can also verify software tools that they’re using by incorporating existing tools to easily audit the software, and they can make use of existing crowd sourcing efforts to stay on top of emerging security vulnerabilities in the software they use. With this we can make the case for open source projects to be adopted by enterprise companies.

Bibliography

Almatari, O. &. (2018, October). Cybersecurity Tools for IS Auditing . Retrieved from https://www.researchgate.net/publication/327369940_Cybersecurity_Tools_for_IS_Auditing

Asay, M. (2018, November 4). Microsoft may be the world’s largest open source contributor, but developers don’t care–yet. Retrieved from https://www.techrepublic.com/article/microsoft-may-be-the-worlds-largest-open-source-contributor-but-developers-dont-yet-care/

Balter, B. (2015, March 9). Open source license usage on GitHub.com . Retrieved from https://github.blog/2015-03-09-open-source-license-usage-on-github-com/

Bui, T. (2014). Analysis of Docker Security. Retrieved from https://arxiv.org/pdf/1501.02967.pdf

Cowan, C. (2003). Software Security for Open-Source Systems. Retrieved from https://journals-scholarsportal-info.myaccess.library.utoronto.ca/pdf/15407993/v01i0001/38_ssfos.xml

DeCausemaker, R. (2014, Oct 22). Head of Open Source at Facebook opens up . Retrieved from https://opensource.com/business/14/10/head-of-open-source-facebook-oscon

Elastic Search. (2019, August). Elastic N.V. Reports Strong Fourth Quarter and Fiscal 2019 Financial Results. Retrieved from https://ir.elastic.co/Cache/1001253311.PDF?O=PDF&T=&Y=&D=&FID=1001253311&iid=5249851

Free Software Foundation. (2019, 07 30). Retrieved from https://www.gnu.org/philosophy/free-sw.en.html

Han, M. (2017, November 16). Introducing security alerts on GitHub . Retrieved from https://github.blog/2017-11-16-introducing-security-alerts-on-github/

Hoepman, J.-H. (2018). Increased security through open source ∗. Retrieved from https://arxiv.org/pdf/0801.3924.pdf

Larabel, M. (2018, September 16). The Linux Kernel Has Grown By 225k Lines of Code So Far This Year From 3.3k Developers . Retrieved from https://www.phoronix.com/scan.php?page=news_item&px=Linux-September-2018-Stats

Marlow, J. (2013). Activity Traces and Signals in Software Developer Recruitment and Hiring. Retrieved from http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.463.6673&rep=rep1&type=pdf

Pennington, H. (2018, March 15). Steve Ballmer was right about open source . Retrieved from tidelift: https://blog.tidelift.com/steve-ballmer-was-right-about-open-source

Raymond, E. S. (2000). The cathedral and the bazaar.

RedHat. (2019, March 25). Retrieved from https://investors.redhat.com/news-and-events/press-releases/2019/03-25-2019-201454520

Stackoverflow. (2019, 07 07). Developer Survey Results 2019. Retrieved from https://insights.stackoverflow.com/survey/2019

Synopsis. (2014, April 29). The Heartbleedbug. Retrieved from heartbleed: http://heartbleed.com/

The Linux Foundation . (2018). Open Source Talent in Demand, With Linux Back on Top. Retrieved from https://www.linuxfoundation.org/publications/2018/06/open-source-jobs-report-2018/

Timmer, J. (2010, August 05). https://arstechnica.com/information-technology/2010/08/court-rules-gpl-part-of-a-well-pleaded-case/. Retrieved from arstechnica: https://arstechnica.com/information-technology/2010/08/court-rules-gpl-part-of-a-well-pleaded-case/

Infamous Heisenbug

2018-03-09T00:00:00+00:00

Solution for NOI00P1 - Cermaic Necklace Heisenbugs are quite interesting but often people will have never heard of the terminology or better yet, experience it in practice. Well today I will show you a heisenbug I encountered while solving a contest problem. This problem had me scratching my head until I had to ask Alex Li during PEG.

This problem is quite trivial after you look through the distracting diagrams. The jist of the problem is that we need to find the largest disk which can be created with the provided variables $\color{white}{V_0}$ and $\color{white}{V_{total}}$.

Offending solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include 
#include 
#include 
using namespace std;

int V,V0,disks,cnt;
double best = 0.0, len = 0.0;

int main() {
    freopen("input.txt","r",stdin);
    scanf("%d%d",&V,&V0);
    //printf("%d %d\n",V,V0);
    for(int i = 1;i <= (int)V/V0;i++){
        len = i*0.3*sqrt((double)V/i-V0);
        //printf("%d %.2f\n",i,len);
        if(len > best){
            best  = len;
            disks = i;
            cnt   = 1;
        }
        else if(len == best){
            cnt++;
        }
    }
    //printf("%d\n",cnt);
    printf("%d\n", (cnt > 1) ? 0:disks);
    return 0;
}

Input, compilation, and output

cat input.txt
10
2
g++ heisenbug.cpp -o heisenbug && time ./heisenbug
3

real    0m0.002s
user    0m0.001s
sys     0m0.000s

So what’s wrong with this solution? Logically it makes sense, it just doesn’t seem to produce the correct answer. More concerning is that when we try debugging the program by printing out each variable we notice that the problem seemingly disapears and produces the correct answer, witchcraft I say!

The issue arises due to C++’s compilation optimizations. The quick fix to this problem is to change the following:

volatile double best = 0.0, len = 0.0;

Why does this work? And what does the volatile keyword do exactly? Here’s a concise definition from Wikipedia.

The volatile keyword indicates that a value may change between different accesses, even if it does not appear to be modified. This keyword prevents an optimizing compiler from optimizing away subsequent reads or writes and thus incorrectly reusing a stale value or omitting writes.

After reading this the problem becomes quite trivial to explain. During compilation C++ took some liberties and assumed that the variable len would not change between accesses. Hence it used a stale/old value of the variables when evaluated the inequalities, thus resulting in an incorrect answer. The volatile keywords now forces the compiler to check the value at the memory registy every time the variable is reffered to, thus fixing the issue.

Input, compilation, and output with modification

cat input.txt
10
2
g++ heisenbug.cpp -o heisenbug && time ./heisenbug
0

real    0m0.002s
user    0m0.001s
sys     0m0.000s

It would seem our little fix worked! Now, some food for thought, why don’t we always use the volatile keyword? Clearly this problem should be affecting all our programs! Well that’s not entirely true. In general the C++ compiler is quite smart and for most cases actually manages to optimize correctly.

Another major point is that forcing the C++ compiler to manually check the value at the registry every time it compiles will cause our program/software to slowdown since it is quite tasking. So make sure to use the volatile keyword sparingly.

Road to Top 10 ORAS OU

2016-10-17T00:00:00+00:00

After years of playing smogon’s ORAS OU metagame I have finally made a spot for myself in the top 10 ranking. I come in at lucky number 7 with an Elo rating of 1959, GXE of 82.3% and a Glicko-1 of 1790 ± 25 (more details). The team I used was the ever popular ABR/Blunder Medi squad, a pastebin can be found here for those who wish to use the team. Now I will pay homage to both my opponent and Robin Williams, Carpe diem: Seize the day.

Highlights

wgma☁️ ³ ³⌚ vs seiz3 the d4y

Battle: 6-2 Win

Ladder Update - 7th place overall

Ottawa Trip - February

2016-09-27T00:00:00+00:00

During our winter reading week me and a couple of students in the Computer Science program decided to take a trip (arranged by UofT) to our countries capital Ottawa! We shared a room in the Cartier Place Suite Hotel and stayed there for three nights. It was bitter cold at times reaching lows of -15°C; fortunately that doesn’t daze the hardiest of Canadians! I gotta meet some great people and I got to network with some great software companies on the visit. Below I have shared some pictures/videos from my trip and hopes that I’ll motivate others like yourself to visit our countries capital.

First day at the Nature Musuem

On our first day in Ottawa we arrived rather late around 4pm. Having a thirst for adventure my roommates and I decided to look online for tourist attractions near our area. To our luck the only location open was the Nature Musuem; and it closed at 5pm. We made haste and battled through mounds of snow that were as high as our knees. We arrived 20 mins before closing and were told by the receptionists that the musuem was free for the last 20 mins. With this knowledge we raced through each floor taking as many pictures as we could. Unfortuantely I only managed to get through three floors, but one of us did manage to get four.

Butterflies don’t actually get this big do they? Just can’t help but to smile back:) Intense

Second day at the Library of Parliament

On our second day in Ottawa we took a trip with the whole group to see the parliament building. It was quite big and and it took our group some time to get through the metal detector gates. We were given a breif tour of the building and were also given a peculiar history of the building. We were told that we were actually standing in the rebuilt version of parliamentary building, as the building was burned down in 1849. Unfortuantely we did not get to examine the house of commons as their was an official meeting going at the time, so instead we were directed to the library. As our guide was telling us the history of the library most of us decided to take a video of the place as it was quite expansive and beautiful.

Final day out in Ottawa

On our final day my we roommates and I decided to split up. A few of us went to the mall, while the others and I went to skate on the Rideau River. This was my first time skating and it was a terrifying but rewarding experience. I remember having my jaw dropp as the occasional rockstars decided to bless us at the skate shack with their awesome moves. For me it was quite frustrating as skating seemed so simple and elegant on television but in reality was quite difficult. I often found myself taking baby steps and pacing along the side of the river in the hopes of me not falling down unlike my friend who fell down every couple of minutes. After skating for an hour I decided to take a break and was approached by a local. I was told that since he was leaving I could help myself to the remaining maple syrup popsicles. And so I did (Please check him out if you’re skating by the river).

On our way back to our hotel we passed through Ottawa Park and noticed a wonderful sight. The image in the middle was a glass art piece that lighted up when the sun started setting. You don’t see that in Toronto everyday. As we continued forward we met up with our other roomates and exchanged some concerns, while we did have fun, we wanted to make our last night memorable. So we decided to eat out in a resturant located in Ottawa’s China Town. Waiting for transit was quite a challenge as we had to a battle with the ever freezing night. Even with my heaviest goose jacket I found my self shivering from the cold. But at last when the bus came we knew our journey was for not. Upon arriving to our destination we saw the warm welcome in the picture to the right and promptly entered the Yangtze restaurant to celebrate our trip.

Me learning how to skate

Ottawa Park

China Town

Overall

I really enjoyed my experience in Ottawa and would definately go back given the chance!

Fire Emblem Awakening - Apostheosis

2016-09-22T06:41:39+00:00

Apostheosis is a DLC map available to fire emblem awakening afficionados wanting to test their strategizing to the fullest. This map pits you against five waves of increasingly harder enemies to face, with the last wave possessing the hardest boss: Anna.

Here I will be posting my Aposthesis team that helped me defeat the map on Lunatic+. Take note that everyone has maxed out stats and all of their weapons are forged with max damage/accuracy.

Pairings

Here you will find what I passed down and my reasoning for most stuff. I generally tried to give everyone Luna since it’s very important on this map. You may be wondering why I passed down some skills like dual support+ and counter. The main reason why I did this is because they gender exclusive skills and all the other passable skills can be obtained through reclassing.

Chrom!Olivia

Comments: Luna and decent mods.
Pass Down: Rightful King, Galeforce
Children: Lucina, Inigo

Ricken!Lissa

Comments: Access to Luna and Magic mods
Pass Down: Luna, Galeforce
Child: Owain

Donnel!Sully

Comments: Galeforce and Mercenary to complete Kjelle’s skill pool.
Pass Down: Counter, Dual Guard+
Child: Kjelle

Stahl!Cordelia

Comments: Great mods, and access to Luna
Pass Down: Swordfaire, Sol
Child: Severa

MU!Tharja

Comments: Great magic mods, and makes Noire have a good move pool.
Pass Down: Counter, Vengeance
Children: Morgan, Noire

Maribelle!Lon’qu

Comments: Vantage + great speed mods to compliment Brady’s move pool.
Pass Down: Vantage, Galeforce
Child: Brady

Frederick!Cherche

Comments: Makes Gerome a very good support unit.
Pass Down: Dual Guard+, Dual Support+
Child: Gerome

Henry!Sumia

Comments: Magic mods, and makes Cynthia a great dark flyer
Pass Down: Counter, Galeforce
Child: Cynthia

Gregor!Miriel

Comments: Really only wanted him to have Armsthrift
Pass Down: Armsthrift, Dual Support+
Child: Laurent

Kellam!Panne

Comments: Makes a great beserker and is a hard counter to Anna
Pass Down: Luna, Lancebreaker
Child: Yarne

Vaike!Nowi

Comments: Makes Nah pretty tank with hellswrath
Pass Down: Axefaire, Deliverer
Child: Nah

Individual Units

Chrom

Class: Paladin
Skills: Aether, Dual Strike+, Dual Guard+, Rightful King, Limit Breaker
Inventory: Brave Sword, Brave Sword, Brace Lance, Brave Lance, Elixer

Morgan

Class: Dark Flier
Skills: Luna, Tomefaire, Armsthrift, Galeforce, Limit Breaker
Inventory: Celica’s Gale, Celica’s Gale, Rescue, Rescue, Elixir

Noire

Class: Dark Flier
Skills: Luna, Tomefaire, Armsthrift, Galeforce, Limit Breaker
Inventory: Celica’s Gale, Celica’s Gale, Rescue, Fortify, Elixir

MU

Class: Sage
Skills: Luna, Aggresor, Tombfaire, Armsthrift, Limit breaker
Inventory: Celica’s Gale, Celica’s Gale, Rescue, Rescue, Elixir

Laurent

Class: Sage
Skills: Sol, Aggresor, Tombfaire, Armsthrift, Limit breaker
Inventory: Celica’s Gale, Fortify, Rescue, Rescue, Elixir

Kjelle

Class: Dark Flier
Skills: Luna, Deliverer, Armsthrift, Galeforce, Limit Breaker
Inventory: Celica’s Gale, Rescue, Fortify, Elixir

Lucina

Class: Assasin
Skills: Dual Strike+, Galeforce, Rightful King, Luna, Limit Breaker
Inventory: Brave Sword, Brave Sword, Brave Bow, Brave Bow, Elixer

Severa

Class: Paladin
Skills: Luna, Swordfaire, Galeforce, Armthrift, Limit Breaker
Inventory: Gradivus, Brave Sword, Brave Lance, Elixer

Inigo

Class: Hero
Skills: Luna, Aggresor, Galeforce, Armthrift, Limit Breaker
Inventory: Brave Sword, Brave Axe, Tomahawk, Elixir

Owain

Class: Sage
Skills: Luna, Aggresor, Tomefaire, Galeforce, Limit Breaker
Inventory: Celica’s Gale, Celica’s Gale, Celica’s Gale, Celica’s Gale, Rescue

Cynthia

Class: Dark Flier
Skills: Luna, Tomefaire, Galeforce, Dual Support+, Limit Breaker
Inventory: Celica’s Gale, Celica’s Gale, Celica’s Gale, Rescue, Rescue

Brady

Class: Sage
Skills: Luna, Aggresor, Tomefaire, Galeforce, Limit Breaker
Inventory: Celica’s Gale, Celica’s Gale, Celica’s Gale, Fortify, Rescue

Lissa

Class: Dark Flier
Skills: Renewal, Tomefaire, Galeforce, Dual Support+, Limit Breaker
Inventory: Celica’s Gale, Celica’s Gale, Fortify, Rescue, Rescue

Ricken

Class: Sage
Skills: Luna, Aggresor, Tomefaire, Dual Guard+, Limit Breaker
Inventory: Celica’s Gale, Celica’s Gale, Fortify, Rescue, Rescue

Gerome

Class: Paladin
Skills: Dual Support+, Dual Guard+, Deliverer, Luna, Limit Breaker
Inventory: Brave Lance, Brave Sword, Brave Sword, Spear, Elixir

Nah

Class: Hero
Skills: Luna, Pavise, Axefaire, Armsthrift, Limit Breaker
Inventory: Brave Sword, Brave Axe, Tomahawk, Hellswrath, Elixir

Yarne

Class: Berserker
Skills: Luna, Lancebreaker, Axefaire, Dual Guard+, Limit Breaker
Inventory: Brave Axe, Brave Axe, Tomahawk, Elixir

Olivia

Class: Dancer
Skills: Swordfaire, Astra, Galeforce, Special Dance, Limit Breaker
Inventory: Brave Sword, Brave Sword, Brave Sword, Elixir

Eldigan

Class: Wyvern Lord
Skills: Rally Strength, Rally Speed, Rally Skill, Rally Defense, Rally Spectrum
Inventory: Brave Lance, Brave Axe

Wilhemina

Class: Falcon Knight
Skills: Rally Magic, Rally Speed, Rally Resistance, Rally Movement, Rally Spectrum
Inventory: Rescue, Rescue, Fortify, Fortify, Goddess Staff

Pair-ups

Brady!Morgan

Power couple, break through enemies with magic power and gale force

Owain!Noire

Power couple, break through enemies with magic power and gale force

Laurent!Cynthia

Power couple, break through enemies with magic power and gale force

Gerome!Lucina

Power couple, and utility couple. Allows Lucina to pick off enemies with insane Luna procs and doubles.

Severa!Inigo

Power couple, break through enemes with strong offenses and gale force

Nah!Yarne

Utility couple, keep yarne alive until Anna comes lol

MU!Kjelle

Power couple, break through enemies with magic power and gale force

Wilhemina (MU from different file), Eldigan

Rally bots

Pokémon Rant #1

2015-10-27T00:00:00+00:00

Ever since the release of Pokémon ORAS (6th generation), I have seen the meta-game evolve in an unexpected way. This once intellectually-stimulating game has fallen from grace and has turned into a meta-game where everyone has decided that their main priority is to status their opponent’s Pokémon. This mentality has caused many players, in my experience, to make brain-dead plays/decisions in battles. This is likely because are no repercussions for doing so, unlike for other statuses like sleep (smogon sleep clause). But before I dive into this topic, how about we take a walk down memory lane and see how the previous generations led up to the current one?

Box art legendaries for DPP

The DPP (Diamond/Pearl/Platinum) meta-game was the 4th installment (generation) of the Pokémon franchise, and was the first installment where there was a prominent online community for competive Pokémon. In the DPP meta-game, OU was arguably the most balanced. Unfortunately, the variety then was quite scarce, since there was a limited selection of Pokémon to choose from. In this meta-game, everything had a check/counter (unless someone got really lucky with Machamp’s DynamicPunch), and all of the play styles (balanced, hyper offense, stall) were quite viable. This meta-game promoted critical thinking, as you had to predict what options your opponent had to take against you in order to win. Also note that, in this generation, status moves like Thunder Wave were not as prevalent as they are now. This environment made for an enjoyable meta-game where the winner of a battle was decided on their skill, and not luck (most of the time).

The 5 central powers for Generation 5 of Pokmeon

After this came the Black and White (5th generation) OU meta-game, where the tier revolved around the following Pokémon: Ninetails, Politoed, Hippowdon, Abomasnow, and Tyranitar. These Pokémon all respectively had the following abilities: Drought (Sun), Drizzle (Rain), Sand Stream (Sandstorm), and Snow Warning (Hail). These weather conditions, for the most part, hindered your opponent’s Pokémon and gave tremendous benefits to your own Pokémon, assuming your team was built well. The most common abusers of these weather conditions were Volcarona (Sun/Rain), Keldeo (Rain), Excadrill (Sand), and Black Kyurem (Hail). From this list of abusers, the most common were Volcarona and Keldeo, who, under the effects of weather, could manage to OHKO or 2HKO almost all opposing Pokémon. Volcarona had its immensely powerful 120BP Fire Blast under the sun (essentially 180 BP) along with its immensely powerful 120BP Hurricane under the rain (100% accurate). Keldeo had its immensely powerful 120 BP hydro pump and utility 80 BP scald (180BP and 120BP respectively under weather). Now, a newcomer may wonder why this was all so instrumental to the meta-game. The simple answer is that throughout this generation weather turns were endless, meaning that these abusers could run rampant through unprepared teams with relative ease. So, in a meta-game with one overly powerful play-style (weather), the meta-game soon became dull, as the same abusers were seen on every team. It is for these reasons the 5th generation was coined as the generation of Weather Wars.

I believe it’s also important to point out that a very game-changing move introduced in this generation was Scald. This move’s secondary affect is quite nasty, as it has a 30% chance to status your opponent with burn, which lowers your opponent’s attack by two stages and removes 12.5% of their health each turn. This was pretty game-changing, since it allowed many users of Scald (primarily water-types) to defeat Pokémon they were never meant to defeat. The classic example is Keldo vs Amoongus. Amoongus completely walls Keldeo (bar HP flying Keldeo), but with some pressure from residual damage from burn and entry hazards it would be worn down quite quickly. Also, most physical attackers had to be much more careful when facing users who carried Scald, as they would risk getting burned and put out of commission for the entire game. Scald’s introduction was likely the entry point for many users to realize the power of RNG based tactics.

Image of all the mega evolutions which were introduced to ORAS and XY

Pokémon XY/ORAS (6th generation) brought with it a slew of new game mechanics. These include: move adjustments, typing adjustments, critical-hit mechanics, weather mechanics, and, the most gaming changing of all, mega evolution. Several move adjustments were made, but I believe the most influential of these would have to be the change to Knock Off. Knock Off received a BP boost, which powered it up from 20BP to 65BP. This, in tandem with its new secondary effect, gave it a 50% BP boost if the opponent was holding an item. This brings Knock Off’s power to a frightening 97.5 BP. But the ride doesn’t stop there: this move became even more powerful due to the typing changes introduced. Game Freak decided that Dark and Ghost types moves had to deal neutral damage against Steel types. These changes, when combined, made the move Knock Off a low-risk, high-reward move, due to its very little resistances, high damage output, and niche in removing the opponent’s item. This change gave rise to Dark type Pokémon like Bisharp being commonly used, as they could take great advantage with their high base attack. Likewise, the other typing changes were game-changing as well. The new Fairy types managed to tame the offensive presence of Dragon-type Pokémon (Since Fairy-types are immune to Dragon-type moves). This new typing also breathed new life into Pokémon like Clefable, Mawile, and Azumarill, which gained impressive offensive and defensive capabilities.

Critical hits (one of the biggest momentum changers) received a buff in the form of frequency (15% chance instead of 7.5% chance) at only a minimal drawback of it dealing 1.5 times the normal damage instead of a 2.0 times. In retrospect, there is no real drawback, since most of the time all you need is a 1.5x boost to kill off an opponent considering how strong Pokémon are nowadays (I’m looking at all of you mega evolutions!).

Now, all these changes weren’t for the worst. In this generation, weather was nerfed and was restricted to 5 turns. This had a tremendous impact on the meta-game, since the representation of weather teams soon became scarce. Ultimately, this change allowed a more diverse array of teams to enter the meta-game.

It is finally time for the bitter sweet implications of the new game mechanics: mega evolution. Mega evolution is great in the fact that it gave spiced up old Pokémon and gave them fresh start. In most cases they made them a lot more viable in a certain aspect (think offense or defense). What I dislike about mega evolutions is the fact that it made several Pokémon too fast, too strong, too bulky, and in general into mindless sweepers. You can probably watch several replays where someone could lead off with a Charizard x, set up with a Dragon Dance then proceed to sweep their opponent’s team. This change resulted in an over-centralized meta-game where it’s mandatory to run your own mega Pokémon to be able to compete with your opponent. The only true counter for these fast and strong threats is Thunder Wave, as it drops their speed just enough so that your strong and fast Pokémon can defeat your opponent’s!

OP Anything Goes team for comedic relief

Now the time has come for my opinion on the current state of the Pokémon meta-game, specifically OU. But firsts lets step back and look of the state of the past meta-games. In the 4th generation the meta-game was balanced, fun, and thought-provoking but was somewhat stale, since there were limited Pokémon from which to create a unique team. The 5th generation adopted the mentality of fighting broken with broken, and consisted of many high-stakes match where one single mistake could cost you the whole game. Both of these meta-games were quite enjoyable, albeit both being quite stale due to variety. Then came the 6th generation, a meta-game so diverse that the chances of you having the same team as your opponent is practically 0. In this meta-game there are so many viable Pokémon that most matches are highly decided on team match-up since every mega evolution can tear a whole through an unprepared team with little ease. So how do we counter the new fast and strong mega evolutions the meta-game? By running your own mega of course! But wait there’s one more thing that almost every player has opted to start running. Yup, you guessed it: Thunder Wave. Since the meta-game is filled with so many fast and strong Pokémon, it’s impossible to have a universal check too; for the majority of them, the only solution is to rely on Thunder Wave, which offers speed control and complete paralysis.

Overall, the meta-game has come along way. We can see that it has had its ups and downs, and every generation had a small issue, be it from variety to broken game mechanics. But we can also see that the game has become more reliant on RNG-based mechanics to deal with threat; this displeases me, since I often see players simply going for these RNG-based tactics since they have no repercussions. However, what’s most infuriating is that sometimes players even choose these tactics over making plays that could win them the game. I can only hope that for Gen 7, Thunder Wave will not be as prevelant.

Welcome!

2014-10-30T00:00:00+00:00

Welcome to my blog! I have recently decided to port over my blog from wgma00.me to this site wgma.ca. Currently this blog is using the Jekyll, which makes the writing blogs easier with markdown.

To kick things here is one of my favourite xkcd comics. It demonstrtes the banter I have with some of my friends about the best editor for a “real programmer” (which is vim hands down).

XKCD 376 - Real Programmers

William Granados

Investments Basics

Income

Deductions (i.e. Taxes)

Debts / Student loans

Tax advantaged accounts

RRSP

TFSA

Investment Options

Budgeting

Why I play a text based game in 2020

The Game: Torn City

The Community

Gameplay

The Older Past(10 yrs ago)

The Old Past (6 yrs ago)

The Somewhat Present - Now (2 yrs ago)

CCC/CCO Selected Solutions (2010-2014)

Introduction

Table of Contents

Solution for CCC10S3 - Firehose

Solution for CCC10S4 - Animal Farm

Solution for CCC10S2P1 - Barking Dogs

Solution for CCC10S2P3 - Wowow

Solution for CCC10S2P2 - Tree Pruning

Solution for CCC10S2P4 - Computer Purchase Return

Solution for CCC10S2P5 - Space Miner

Solution for CCC11S3 - Alice Through the Looking Glass

Base Cases

Recursive Case

Solution for CCC11S5 - Switch

Solution for CCC11S2P2 - Vampire Tunnels

Solution for CCC11S2P3 - Reorganization

Solution for CCC11S2P3 - Spies Like Us

Solution for CCC12S4 - A Coin Game

Solution for CCC12S2P2 - The Hungary Games

Solution for CCC12S2P3 - Mhocksian Languages

Solution for CCC13S2P2 - Tourney

Solution for CCC13S2P3 - LHC

Solution for CCC14S4 - Tinted Glass Windows

Open Source in the Enterprise

Abstract

Introduction

Benefits of Open Source Software

Public Opinion from Developers of Open Source

Profitability in Open Source

Case study of Elastic Search

Case study of Red Hat

Legal adoption – Open Source Licensing

Copyleft Licenses

Weak Copyleft Licenses

Strong Copyleft Licenses

Security of Open Source Software

Security: Open Source vs Closed Source

Auditing techniques for Open Source Software

Static Code Analyzers

Cloud based solutions

Crowd sourcing

Closing Remarks

Bibliography

Infamous Heisenbug

Road to Top 10 ORAS OU

Highlights

Ottawa Trip - February

First day at the Nature Musuem

Second day at the Library of Parliament

Final day out in Ottawa

Overall

Fire Emblem Awakening - Apostheosis

Pairings

Chrom!Olivia

Ricken!Lissa

Donnel!Sully

Stahl!Cordelia

MU!Tharja

Maribelle!Lon’qu

Frederick!Cherche

Henry!Sumia

Gregor!Miriel

Kellam!Panne