fix(guide) Replace invalid prism code block names (#35961)

* fix: replace sh with shell

fix replace terminal with shell

fix replace node with js

fix replace output with shell

fix replace cs with csharp

fix replace c++ with cpp

fix replace c# with csharp

fix replace javasctipt with js

fix replace syntax  with js

fix replace unix with shell

fix replace linux with shell

fix replace java 8 with java

fix replace swift4 with swift

fix replace react.js with jsx

fix replace javascriot with js

fix replace javacsript with js

fix replace c++ -  with cpp

fix: corrected various typos

fix: replace Algorithm with nothing

fix: replace xaml with xml

fix: replace solidity with nothing

fix: replace c++ with cpp

fix: replace txt with shell

fix: replace code with json and css

fix: replace console with shell

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

@@ -123,7 +123,7 @@ public class bubble-sort {
 
 ### La implementación recursiva del Bubble Sort.
 
-```c++
+```cpp
 void bubblesort(int arr[], int n) 
  { 
     if(n==1)    //Initial Case 

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

@@ -67,7 +67,7 @@ import java.util.Arrays;
 
 implementación en C ++
 
-```C++
+```cpp
 #include <iostream> 
  using namespace std; 
  void heapify(int arr[], int n, int i) 

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

@@ -92,7 +92,7 @@ Paso 5:
 
 El algoritmo siguiente es una versión ligeramente optimizada para evitar el intercambio de elementos `key` en cada iteración. Aquí, el elemento `key` se intercambiará al final de la iteración (paso).
 
-```Algorithm
+```
     InsertionSort(arr[]) 
       for j = 1 to arr.length 
          key = arr[j] 

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

@@ -23,7 +23,7 @@ T(n) = 2T(n/2) + n
 
 Contando el número de repeticiones de n en la suma al final, vemos que hay lg n + 1 de ellas. Por lo tanto, el tiempo de ejecución es n (lg n + 1) = n lg n + n. Observamos que n lg n + n <n lg n + n lg n = 2n lg n para n> 0, por lo que el tiempo de ejecución es O (n lg n).
 
-```Algorithm
+```
 MergeSort(arr[], left,  right): 
  If right > l: 
      1. Find the middle point to divide the array into two halves: