Fix language annotation of code blocks

algmyr · algmyr · commit 500067966066 · 2018-08-17T11:28:15.000+02:00
diff --git a/src/algebra/big-integer.md b/src/algebra/big-integer.md
@@ -16,13 +16,13 @@ Here we describe long arithmetic for only non-negative integers. To extend the a
 
 We'll store numbers as a `vector<int>`, in which each element is a single "digit" of the number.
 
-```
+```cpp
 typedef vector<int> lnum;
 ```
 
 To improve performance we'll use $10^9$ as the base, so that each "digit" of the long number contains 9 decimal digits at once.
 
-```
+```cpp
 const int base = 1000*1000*1000;
 ```
 
@@ -32,7 +32,7 @@ Digits will be stored in order from least to most significant. All operations wi
 
 Printing the long integer is the easiest operation. First we print the last element of the vector (or 0 if the vector is empty), followed by the rest of the elements padded with leading zeros if necessary so that they are exactly 9 digits long.
 
-```
+```cpp
 printf ("%d", a.empty() ? 0 : a.back());
 for (int i=(int)a.size()-2; i>=0; --i)
 	printf ("%09d", a[i]);
@@ -44,7 +44,7 @@ Note that we cast `a.size()` to integer to avoid unsigned integer underflow if v
 
 To read a long integer, read its notation into a `string` and then convert it to "digits":
 
-```
+```cpp
 for (int i=(int)s.length(); i>0; i-=9)
 	if (i < 9)
 		a.push_back (atoi (s.substr (0, i).c_str()));
@@ -54,7 +54,7 @@ for (int i=(int)s.length(); i>0; i-=9)
 
 If we use an array of `char` instead of a `string`, the code will be even shorter:
 
-```
+```cpp
 for (int i=(int)strlen(s); i>0; i-=9) {
 	s[i] = 0;
 	a.push_back (atoi (i>=9 ? s+i-9 : s));
@@ -63,7 +63,7 @@ for (int i=(int)strlen(s); i>0; i-=9) {
 
 If the input can contain leading zeros, they can be removed as follows:
 
-```
+```cpp
 while (a.size() > 1 && a.back() == 0)
 	a.pop_back();
 ```
@@ -72,7 +72,7 @@ while (a.size() > 1 && a.back() == 0)
 
 Increment long integer $a$ by $b$ and store result in $a$:
 
-```
+```cpp
 int carry = 0;
 for (size_t i=0; i<max(a.size(),b.size()) || carry; ++i) {
 	if (i == a.size())
@@ -87,7 +87,7 @@ for (size_t i=0; i<max(a.size(),b.size()) || carry; ++i) {
 
 Decrement long integer $a$ by $b$ ($a \ge b$) and store result in $a$:
 
-```
+```cpp
 int carry = 0;
 for (size_t i=0; i<b.size() || carry; ++i) {
 	a[i] -= carry + (i < b.size() ? b[i] : 0);
@@ -104,7 +104,7 @@ Note that after performing subtraction we remove leading zeros to keep up with t
 
 Multiply long integer $a$ by short integer $b$ ($b < base$) and store result in $a$:
 
-```
+```cpp
 int carry = 0;
 for (size_t i=0; i<a.size() || carry; ++i) {
 	if (i == a.size())
@@ -123,7 +123,7 @@ Additional optimization: If runtime is extremely important, you can try to repla
 
 Multiply long integers $a$ and $b$ and store result in $c$:
 
-```
+```cpp
 lnum c (a.size()+b.size());
 for (size_t i=0; i<a.size(); ++i)
 	for (int j=0, carry=0; j<(int)b.size() || carry; ++j) {
@@ -139,7 +139,7 @@ while (c.size() > 1 && c.back() == 0)
 
 Divide long integer $a$ by short integer $b$ ($b < base$), store integer result in $a$ and remainder in `carry`:
 
-```
+```cpp
 int carry = 0;
 for (int i=(int)a.size()-1; i>=0; --i) {
 	long long cur = a[i] + carry * 1ll * base;
diff --git a/src/algebra/gray-code.md b/src/algebra/gray-code.md
@@ -12,7 +12,7 @@ This code was invented by Frank Gray in 1953.
 
 Let's look at the bits of number $n$ and the bits of number $G(n)$. Notice that $i$-th bit of $G(n)$ equals 1 only when $i$-th bit of $n$ equals 1 and $i + 1$-th bit equals 0 or the other way around ($i$-th bit equals 0 and $i + 1$-th bit equals 1). Thus, $G(n) = n \oplus (n >> 1)$:  
 
-```   
+```cpp
   int g (int n) { 
 	  return n ^ (n >> 1); 
   }
@@ -32,7 +32,7 @@ We will move from the most significant bits to the least significant ones (the l
 
 The easiest way to write it in code is:
 
-```
+```cpp
   int rev_g (int g) {
     int n = 0;
     for (; g; g >>= 1)
diff --git a/src/algebra/phi-function.md b/src/algebra/phi-function.md
@@ -32,33 +32,37 @@ $$= n \cdot \left(1 - \frac{1}{p_1}\right) \cdot \left(1 - \frac{1}{p_2}\right)
 
 `C++` implementation using factorization in $O(\sqrt{n})$ <span class="toggle-code">Show/Hide</span>
 
-	int phi(int n) {
-		int result = n;
-		for(int i = 2; i * i <= n; ++i)
-			if(n % i == 0) {
-				while(n % i == 0)
-					n /= i;
-				result -= result / i;
-			}
-		if(n > 1)
-			result -= result / n;
-		return result;
-	}
+```cpp
+int phi(int n) {
+    int result = n;
+    for(int i = 2; i * i <= n; ++i)
+        if(n % i == 0) {
+            while(n % i == 0)
+                n /= i;
+            result -= result / i;
+        }
+    if(n > 1)
+        result -= result / n;
+    return result;
+}
+```
 
 `Python 3` implementation <span class="toggle-code">Show/Hide</span>
 
-    def phi(n):
-	    result = n
-	    i = 2
-	    while i * i <= n:
-		    if n % i == 0:
-			    while n % i == 0:
-				    n //= i
-			    result -= result // i
-		    i += 1
-	    if n > 1:
-		    result -= result // n
-	    return result
+```python
+def phi(n):
+    result = n
+    i = 2
+    while i * i <= n:
+        if n % i == 0:
+            while n % i == 0:
+                n //= i
+            result -= result // i
+        i += 1
+    if n > 1:
+        result -= result // n
+    return result
+```
 
 ## Applications of Euler's totient function
 
diff --git a/src/data_structures/sqrt-tree.md b/src/data_structures/sqrt-tree.md
@@ -186,7 +186,7 @@ Note that when we do the recursive call, we do prefix or suffix $\text{massUpdat
 
 The following implementation of Sqrt Tree can perform the following operations: build in $O(n \cdot \log \log n)$, answer queries in $O(1)$ and update an element in $O(\sqrt{n})$.
 
-~~~~~
+~~~~~cpp
 SqrtTreeItem op(const SqrtTreeItem &a, const SqrtTreeItem &b);
 
 inline int log2Up(int n) {
diff --git a/src/data_structures/treap.md b/src/data_structures/treap.md
@@ -53,7 +53,7 @@ We implement **Build** operation with $O (N \log N)$ complexity using $N$ **Inse
 
 ## Implementation
 
-```
+```cpp
 struct item {
 	int key, prior;
 	item * l, * r;
@@ -113,7 +113,7 @@ To extend the functionality of the treap, it is often necessary to store the num
 
 When a tree changes (nodes are added or removed etc.), `cnt` of some nodes should be updated accordingly. We'll create two functions: `cnt()` will return the current value of `cnt` or 0 if the node does not exist, and `upd_cnt()` will update the value of `cnt` for this node assuming that for its children L and R the values of `cnt` have already been updated. Evidently it's sufficient to add calls of `upd_cnt()` to the end of `insert`, `erase`, `split` and `merge` to keep `cnt` values up-to-date.
 
-```
+```cpp
 int cnt (pitem t) {
 	return t ? t->cnt : 0;
 }
@@ -147,7 +147,7 @@ Now it's clear how to calculate the implicit key of current node quickly. Since
 
 Here are the new implementations of **Split** and **Merge**:
 
-```
+```cpp
 void merge (pitem & t, pitem l, pitem r) {
 	if (!l || !r)
 		t = l ? l : r;
@@ -187,7 +187,7 @@ Now let's consider the implementation of various operations on implicit treaps:
 
 Here is an example implementation of the implicit treap with reverse on the interval. For each node we store field called `value` which is the actual value of the array element at current position. We also provide implementation of the function `output()`, which outputs an array that corresponds to the current state of the implicit treap.
 
-```
+```cpp
 typedef struct item * pitem;
 struct item {
 	int prior, value, cnt;
diff --git a/src/geometry/area-of-simple-polygon.md b/src/geometry/area-of-simple-polygon.md
@@ -12,7 +12,7 @@ $$A = \sum_{(p,q)\in \text{edges}} \frac{(p_x - q_x) \cdot (p_y + q_y)}{2}$$
 
 Code:
 
-```
+```cpp
 double area(const vector<point>& fig) {
     double res = 0;
     for (unsigned i = 0; i < fig.size(); i++) {
@@ -27,4 +27,4 @@ double area(const vector<point>& fig) {
 ## Method 2
 We can choose a point $O$ arbitrarily, iterate over all edges adding the oriented area of the triangle formed by the edge and point $O$. Again, due to the sign of area, extra area will be reduced.
 
-This method is better as it can be generalized to more complex cases (such as when some sides are arcs instead of straight lines)
+This method is better as it can be generalized to more complex cases (such as when some sides are arcs instead of straight lines)
diff --git a/src/graph/strongly-connected-components.md b/src/graph/strongly-connected-components.md
@@ -49,6 +49,7 @@ Algorithm asymptotics is $O(n + m)$, because it is just two depth (breadth) firs
 Finally, it is appropriate to mention [topological sort](http://e-maxx-eng.appspot.com/graph/topological-sort.html) here. First of all, step 1 of the algorithm represents topological sort of graph $G$ (actually this is exactly what vertices' sort by exit time means). Secondly, the algorithm's scheme generates strongly connected components by decreasing order of their exit times, thus it generates components - vertices of condensation graph - in topological sort order.
 
 ## Implementation
+```cpp
     vector < vector<int> > g, gr;
     vector<char> used;
     vector<int> order, component;
@@ -93,6 +94,7 @@ Finally, it is appropriate to mention [topological sort](http://e-maxx-eng.appsp
             }
         }
     }
+```
 
 Here, $g$ is graph, $gr$ is transposed graph. Function $dfs1$ implements depth first search on graph $G$, function $dfs2$ - on transposed graph $G^T$. Function $dfs1$ fills the list $order$ with vertices in increasing order of their exit times (actually, it is making a topological sort). Function $dfs2$ stores all reached vertices in list $component$, that is going to store next strongly connected component after each run.
 

Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,7 @@ Algorithm asymptotics is $O(n + m)$, because it is just two depth (breadth) firs`
`49`	`49`	`Finally, it is appropriate to mention [topological sort](http://e-maxx-eng.appspot.com/graph/topological-sort.html) here. First of all, step 1 of the algorithm represents topological sort of graph $G$ (actually this is exactly what vertices' sort by exit time means). Secondly, the algorithm's scheme generates strongly connected components by decreasing order of their exit times, thus it generates components - vertices of condensation graph - in topological sort order.`
`50`	`50`
`51`	`51`	`## Implementation`
	`52`	+```cpp
`52`	`53`	`vector < vector<int> > g, gr;`
`53`	`54`	`vector<char> used;`
`54`	`55`	`vector<int> order, component;`
`@@ -93,6 +94,7 @@ Finally, it is appropriate to mention [topological sort](http://e-maxx-eng.appsp`
`93`	`94`	`}`
`94`	`95`	`}`
`95`	`96`	`}`
	`97`	+```
`96`	`98`
`97`	`99`	`Here, $g$ is graph, $gr$ is transposed graph. Function $dfs1$ implements depth first search on graph $G$, function $dfs2$ - on transposed graph $G^T$. Function $dfs1$ fills the list $order$ with vertices in increasing order of their exit times (actually, it is making a topological sort). Function $dfs2$ stores all reached vertices in list $component$, that is going to store next strongly connected component after each run.`
`98`	`100`