fix(guide): radix sort formatting/inconsistencies (#36507)

* fix(guide): radix sort formatting/inconsistencies

Signed-off-by: Jonathan <theflametrooper@gmail.com>

* fix(guide): radix sort spacing should be 2 spaces

Signed-off-by: Jonathan <theflametrooper@gmail.com>

guide/arabic/algorithms/sorting-algorithms/radix-sort/index.md

@@ -59,54 +59,71 @@ QuickSort و MergeSort و HeapSort هي خوارزميات الفرز على أ
 
 تنفيذ في C:
 
-```
+```c
 void countsort(int arr[],int n,int place){
+  int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9 
+  int output[n];
 
-        int i,freq[range]={0};         //range for integers is 10 as digits range from 0-9
-
-        int output[n];
-
-        for(i=0;i<n;i++)
-
-                freq[(arr[i]/place)%range]++;
-
-        for(i=1;i<range;i++)
-
-                freq[i]+=freq[i-1];
-
-        for(i=n-1;i>=0;i--){
-
-                output[freq[(arr[i]/place)%range]-1]=arr[i];
-
-                freq[(arr[i]/place)%range]--;
-
-        }
-
-        for(i=0;i<n;i++)
-
-                arr[i]=output[i];
-
+  for(i=0;i<n;i++)
+    freq[(arr[i]/place)%range]++;
+ 
+  for(i=1;i<range;i++)
+    freq[i]+=freq[i-1];
+ 
+  for(i=n-1;i>=0;i--){
+    output[freq[(arr[i]/place)%range]-1]=arr[i];
+    freq[(arr[i]/place)%range]--;
+  }
+ 
+  for(i=0;i<n;i++)
+    arr[i]=output[i];
 }
-
-void radixsort(ll arr[],int n,int maxx){            //maxx is the maximum element in the array
-
-        int mul=1;
-
-        while(maxx){
-
-                countsort(arr,n,mul);
-
-                mul*=10;
-
-                maxx/=10;
-
-        }
-
+ 
+void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
+  int mul=1;
+  while(maxx){
+    countsort(arr,n,mul);
+    mul*=10;
+    maxx/=10;
+  }
 }
-``` 
+```
 
-### معلومات اكثر:
+Python:
+
+```py
+def counting_sort(arr, max_value, get_index):
+  counts = [0] * max_value
+
+  # Counting - O(n)
+  for a in arr:s
+    counts[get_index(a)] += 1
+  
+  # Accumulating - O(k)
+  for i, c in enumerate(counts):
+    if i == 0:
+      continue
+    else:
+      counts[i] += counts[i-1]
+
+  # Calculating start index - O(k)
+  for i, c in enumerate(counts[:-1]):
+    if i == 0:
+      counts[i] = 0
+    counts[i+1] = c
+
+  ret = [None] * len(arr)
+  # Sorting - O(n)
+  for a in arr:
+    index = counts[get_index(a)]
+    ret[index] = a
+    counts[get_index(a)] += 1
+  
+  return ret
+```
+
+### معلومات اكثر
 
 *   [ويكيبيديا](https://en.wikipedia.org/wiki/Radix_sort)
     
-*   [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)
+*   [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)

guide/chinese/algorithms/sorting-algorithms/radix-sort/index.md

@@ -58,54 +58,72 @@ QuickSort，MergeSort，HeapSort是基于比较的排序算法。 CountSort不
 该数组变为：10,11,17,21,34,44,123,654，它被排序。这就是我们的算法的工作方式。
 
 C中的实现：
-```
-void countsort(int arr[],int n,int place){ 
+
+```c
+void countsort(int arr[],int n,int place){
+  int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9 
+  int output[n];
+
+  for(i=0;i<n;i++)
+    freq[(arr[i]/place)%range]++;
  
-        int i,freq[range]={0};         //range for integers is 10 as digits range from 0-9 
+  for(i=1;i<range;i++)
+    freq[i]+=freq[i-1];
  
-        int output[n]; 
+  for(i=n-1;i>=0;i--){
+    output[freq[(arr[i]/place)%range]-1]=arr[i];
+    freq[(arr[i]/place)%range]--;
+  }
  
-        for(i=0;i<n;i++) 
+  for(i=0;i<n;i++)
+    arr[i]=output[i];
+}
  
-                freq[(arr[i]/place)%range]++; 
- 
-        for(i=1;i<range;i++) 
- 
-                freq[i]+=freq[i-1]; 
- 
-        for(i=n-1;i>=0;i--){ 
- 
-                output[freq[(arr[i]/place)%range]-1]=arr[i]; 
- 
-                freq[(arr[i]/place)%range]--; 
- 
-        } 
- 
-        for(i=0;i<n;i++) 
- 
-                arr[i]=output[i]; 
- 
- } 
- 
- void radixsort(ll arr[],int n,int maxx){            //maxx is the maximum element in the array 
- 
-        int mul=1; 
- 
-        while(maxx){ 
- 
-                countsort(arr,n,mul); 
- 
-                mul*=10; 
- 
-                maxx/=10; 
- 
-        } 
- 
- } 
+void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
+  int mul=1;
+  while(maxx){
+    countsort(arr,n,mul);
+    mul*=10;
+    maxx/=10;
+  }
+}
 ```
 
-### 更多信息：
+Python:
+
+```py
+def counting_sort(arr, max_value, get_index):
+  counts = [0] * max_value
+
+  # Counting - O(n)
+  for a in arr:s
+    counts[get_index(a)] += 1
+  
+  # Accumulating - O(k)
+  for i, c in enumerate(counts):
+    if i == 0:
+      continue
+    else:
+      counts[i] += counts[i-1]
+
+  # Calculating start index - O(k)
+  for i, c in enumerate(counts[:-1]):
+    if i == 0:
+      counts[i] = 0
+    counts[i+1] = c
+
+  ret = [None] * len(arr)
+  # Sorting - O(n)
+  for a in arr:
+    index = counts[get_index(a)]
+    ret[index] = a
+    counts[get_index(a)] += 1
+  
+  return ret
+```
+
+### 更多信息
 
 *   [维基百科](https://en.wikipedia.org/wiki/Radix_sort)
     
-*   [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)
+*   [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)

guide/english/algorithms/sorting-algorithms/radix-sort/index.md

@@ -66,36 +66,38 @@ Finally , we sort according to the hundred's digit (most significant digit):
 The array becomes : 10, 11, 17, 21, 34, 44, 123, 654 which is sorted. This is how our algorithm works. 
 
 An implementation in C:
+
 ```c
 void countsort(int arr[],int n,int place){
-  int i,freq[range]={0};         //range for integers is 10 as digits range from 0-9 
+  int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9 
   int output[n];
 
   for(i=0;i<n;i++)
-        freq[(arr[i]/place)%range]++;
+    freq[(arr[i]/place)%range]++;
  
   for(i=1;i<range;i++)
-        freq[i]+=freq[i-1];
+    freq[i]+=freq[i-1];
  
   for(i=n-1;i>=0;i--){
-        output[freq[(arr[i]/place)%range]-1]=arr[i];
-        freq[(arr[i]/place)%range]--;
+    output[freq[(arr[i]/place)%range]-1]=arr[i];
+    freq[(arr[i]/place)%range]--;
   }
  
   for(i=0;i<n;i++)
-        arr[i]=output[i];
+    arr[i]=output[i];
 }
  
-void radixsort(ll arr[],int n,int maxx){            //maxx is the maximum element in the array
+void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
   int mul=1;
   while(maxx){
-        countsort(arr,n,mul);
-        mul*=10;
-        maxx/=10;
-   }
+    countsort(arr,n,mul);
+    mul*=10;
+    maxx/=10;
+  }
 }
 ```
-An implementation in python :
+
+An implementation in Python:
 
 ```py
 def counting_sort(arr, max_value, get_index):
@@ -128,7 +130,7 @@ def counting_sort(arr, max_value, get_index):
   return ret
 ```
 
-### More Information:
+### More Information
 
 - [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort)
 

guide/portuguese/algorithms/sorting-algorithms/radix-sort/index.md

@@ -58,37 +58,38 @@ Agora, o array se torna: 10,11,17,21,123,34,44,654 Finalmente, classificamos de
 A matriz torna-se: 10,11,17,21,34,44,123,654 que é classificada. É assim que nosso algoritmo funciona.
 
 Uma implementação em C:
+
 ```c
 void countsort(int arr[],int n,int place){
   int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9 
   int output[n];
 
   for(i=0;i<n;i++)
-        freq[(arr[i]/place)%range]++;
+    freq[(arr[i]/place)%range]++;
  
   for(i=1;i<range;i++)
-        freq[i]+=freq[i-1];
+    freq[i]+=freq[i-1];
  
   for(i=n-1;i>=0;i--){
-        output[freq[(arr[i]/place)%range]-1]=arr[i];
-        freq[(arr[i]/place)%range]--;
+    output[freq[(arr[i]/place)%range]-1]=arr[i];
+    freq[(arr[i]/place)%range]--;
   }
  
   for(i=0;i<n;i++)
-        arr[i]=output[i];
+    arr[i]=output[i];
 }
  
 void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
   int mul=1;
   while(maxx){
-        countsort(arr,n,mul);
-        mul*=10;
-        maxx/=10;
-   }
+    countsort(arr,n,mul);
+    mul*=10;
+    maxx/=10;
+  }
 }
 ```
 
-Uma implementação em Python :
+Uma implementação em Python:
 
 ```py
 def counting_sort(arr, max_value, get_index):
@@ -121,7 +122,7 @@ def counting_sort(arr, max_value, get_index):
   return ret
 ```
 
-### Mais Informações:
+### Mais Informações
 
 *   [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort)
     

guide/russian/algorithms/sorting-algorithms/radix-sort/index.md

@@ -58,54 +58,73 @@ QuickSort, MergeSort, HeapSort - это алгоритмы сортировки
 Массив становится: 10,11,17,21,34,44,123,654, который сортируется. Так работает наш алгоритм.
 
 Реализация в C:
-```
-void countsort(int arr[],int n,int place){ 
+
+```c
+void countsort(int arr[],int n,int place){
+  int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9 
+  int output[n];
+
+  for(i=0;i<n;i++)
+    freq[(arr[i]/place)%range]++;
  
-        int i,freq[range]={0};         //range for integers is 10 as digits range from 0-9 
+  for(i=1;i<range;i++)
+    freq[i]+=freq[i-1];
  
-        int output[n]; 
+  for(i=n-1;i>=0;i--){
+    output[freq[(arr[i]/place)%range]-1]=arr[i];
+    freq[(arr[i]/place)%range]--;
+  }
  
-        for(i=0;i<n;i++) 
+  for(i=0;i<n;i++)
+    arr[i]=output[i];
+}
  
-                freq[(arr[i]/place)%range]++; 
- 
-        for(i=1;i<range;i++) 
- 
-                freq[i]+=freq[i-1]; 
- 
-        for(i=n-1;i>=0;i--){ 
- 
-                output[freq[(arr[i]/place)%range]-1]=arr[i]; 
- 
-                freq[(arr[i]/place)%range]--; 
- 
-        } 
- 
-        for(i=0;i<n;i++) 
- 
-                arr[i]=output[i]; 
- 
- } 
- 
- void radixsort(ll arr[],int n,int maxx){            //maxx is the maximum element in the array 
- 
-        int mul=1; 
- 
-        while(maxx){ 
- 
-                countsort(arr,n,mul); 
- 
-                mul*=10; 
- 
-                maxx/=10; 
- 
-        } 
- 
- } 
+void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
+  int mul=1;
+  while(maxx){
+    countsort(arr,n,mul);
+    mul*=10;
+    maxx/=10;
+  }
+}
 ```
 
-### Дополнительная информация:
+Python:
+
+```py
+def counting_sort(arr, max_value, get_index):
+  counts = [0] * max_value
+
+  # Counting - O(n)
+  for a in arr:s
+    counts[get_index(a)] += 1
+  
+  # Accumulating - O(k)
+  for i, c in enumerate(counts):
+    if i == 0:
+      continue
+    else:
+      counts[i] += counts[i-1]
+
+  # Calculating start index - O(k)
+  for i, c in enumerate(counts[:-1]):
+    if i == 0:
+      counts[i] = 0
+    counts[i+1] = c
+
+  ret = [None] * len(arr)
+  # Sorting - O(n)
+  for a in arr:
+    index = counts[get_index(a)]
+    ret[index] = a
+    counts[get_index(a)] += 1
+  
+  return ret
+```
+
+
+### Дополнительная информация
 
 *   [Википедия](https://en.wikipedia.org/wiki/Radix_sort)
     
-*   [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)
+*   [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)

guide/spanish/algorithms/sorting-algorithms/radix-sort/index.md

@@ -58,54 +58,72 @@ Ahora, la matriz se convierte en: 10,11,17,21,123,34,44,654 Finalmente, ordenamo
 La matriz se convierte en: 10,11,17,21,34,44,123,654 que está ordenada. Así es como funciona nuestro algoritmo.
 
 Una implementación en C:
-```
-void countsort(int arr[],int n,int place){ 
+
+```c
+void countsort(int arr[],int n,int place){
+  int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9 
+  int output[n];
+
+  for(i=0;i<n;i++)
+    freq[(arr[i]/place)%range]++;
  
-        int i,freq[range]={0};         //range for integers is 10 as digits range from 0-9 
+  for(i=1;i<range;i++)
+    freq[i]+=freq[i-1];
  
-        int output[n]; 
+  for(i=n-1;i>=0;i--){
+    output[freq[(arr[i]/place)%range]-1]=arr[i];
+    freq[(arr[i]/place)%range]--;
+  }
  
-        for(i=0;i<n;i++) 
+  for(i=0;i<n;i++)
+    arr[i]=output[i];
+}
  
-                freq[(arr[i]/place)%range]++; 
- 
-        for(i=1;i<range;i++) 
- 
-                freq[i]+=freq[i-1]; 
- 
-        for(i=n-1;i>=0;i--){ 
- 
-                output[freq[(arr[i]/place)%range]-1]=arr[i]; 
- 
-                freq[(arr[i]/place)%range]--; 
- 
-        } 
- 
-        for(i=0;i<n;i++) 
- 
-                arr[i]=output[i]; 
- 
- } 
- 
- void radixsort(ll arr[],int n,int maxx){            //maxx is the maximum element in the array 
- 
-        int mul=1; 
- 
-        while(maxx){ 
- 
-                countsort(arr,n,mul); 
- 
-                mul*=10; 
- 
-                maxx/=10; 
- 
-        } 
- 
- } 
+void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
+  int mul=1;
+  while(maxx){
+    countsort(arr,n,mul);
+    mul*=10;
+    maxx/=10;
+  }
+}
 ```
 
-### Más información:
+Python:
+
+```py
+def counting_sort(arr, max_value, get_index):
+  counts = [0] * max_value
+
+  # Counting - O(n)
+  for a in arr:s
+    counts[get_index(a)] += 1
+  
+  # Accumulating - O(k)
+  for i, c in enumerate(counts):
+    if i == 0:
+      continue
+    else:
+      counts[i] += counts[i-1]
+
+  # Calculating start index - O(k)
+  for i, c in enumerate(counts[:-1]):
+    if i == 0:
+      counts[i] = 0
+    counts[i+1] = c
+
+  ret = [None] * len(arr)
+  # Sorting - O(n)
+  for a in arr:
+    index = counts[get_index(a)]
+    ret[index] = a
+    counts[get_index(a)] += 1
+  
+  return ret
+```
+
+### Más información
 
 *   [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort)
     
-*   [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)
+*   [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)