<style>
 @import url('https://fonts.googleapis.com/css2?family=Fira+Code:wght@500&family=Nanum+Gothic+Coding&display=swap');
</style>
<main id="main-doc">
<nav id="navbar">
<header>Sorting Algorithms</header>
   <a href="#Defintion" class="nav-link">Defintion</a>
   <a href="#Bubble_sort" class="nav-link">Bubble Sort</a>
   <a href="#Selection_sort" class="nav-link">Selection Sort</a>
   <a href="#Inserting_sort" class="nav-link">Inserting Sort</a>
   <a href="#Quick_sort" class="nav-link">Quick Sort</a>
   <a href="#Merge_sort" class="nav-link">Merge Sort</a>
   <a href="#Binary_Search" class="nav-link">Binary Search</a>
   <a href="#Big_O" class="nav-link">Big O</a>
   <a href="#Time_Complexity" class="nav-link">Time Complexity</a>
   
   
  </nav>
   <section class="main-section" id="Defintion">
    <header>Defintion</header>
     
    <p>
      In computer science, a sorting algorithm is an algorithm that puts elements of a list into an order. The most frequently used orders are numerical order and lexicographical order, and either ascending or descending. Efficient sorting is important for optimizing the efficiency of other algorithms (such as search and merge algorithms) that require input data to be in sorted lists. Sorting is also often useful for canonicalizing data and for producing human-readable output.
    </p>

  </section>
  
   <section class="main-section" id="Bubble_sort">
    <header>Bubble Sort</header>
    <p>
      The bubble sort method starts at the beginning of an unsorted array and 'bubbles up' unsorted values towards the end, iterating through the array until it is completely sorted. It does this by comparing adjacent items and swapping them if they are out of order. The method continues looping through the array until no swaps occur at which point the array is sorted.
      <br>
        here is Example of Bubble sort in JavaScript:
      <br>
    <p class="code">
    
      <code>
<span class="Enum">1:</span>&emsp;<span class="key-function">function</span> <span class="function">selectionSort</span><span class="marker">(</span><span class="var">array</span><span class="marker">)</span> <span class="marker">{</span><br>
<span class="Enum">2:</span>        &emsp;<span class="keys">let</span> <span class="var">min</span><span class="operator">=</span><span class="num">100000</span><span class="marker">;</span><br>
<span class="Enum">3:</span>        &emsp;<span class="keys">let</span> <span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">4:</span>        &emsp;&emsp;<span class="loops">for</span><span class="marker">(</span><span class="keys">let</span> <span class="var">j</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><span class="var">j</span> <span class="operator"><</span><span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">j</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">5:</span>           &emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">6:</span> &emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">7:</span> &emsp;&emsp;&emsp;<span class="loops">for</span> <span class="marker">(</span><span class="keys">let</span><span class="var">i</span><span class="operator">=</span><span class="var">j</span><span class="marker">;</span><span class="var">i</span> <span class="operator"><</span> <span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">i</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">8:</span>        &emsp;&emsp;&emsp;&emsp;<span class="conditions">if</span><span class="marker">(</span><span class="var">min</span><span class="operator">></span> <span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">){</span><br>
<span class="Enum">9:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">10:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">11:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">12:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="operator">=</span><span class="var">temp</span><span class="marker">;</span><br>
<span class="Enum">13:</span>&emsp;&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">14:</span>&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">15:</span>&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">16:</span>&emsp;<span class="keys">return</span> <span class="var">array</span><span class="marker">;</span><br>
<span class="Enum">17:</span>&emsp;<span class="marker">}</span><br>
 </p>
   
    </p>

  </section>
  
   <section class="main-section" id="Selection_sort">
    <header>Selection Sort</header>
    <p>
     Selection sort works by selecting the minimum value in a list and swapping it with the first value in the list. It then starts at the second position, selects the smallest value in the remaining list, and swaps it with the second element. It continues iterating through the list and swapping elements until it reaches the end of the list. Now the list is sorted. Selection sort has quadratic time complexity in all cases.      <br>
        here is Example of Selection sort in JavaScript:
      <br>
       <p class="code">
      <code>
<span class="Enum">1:</span>&emsp;<span class="key-function">function</span> <span class="function">selectionSort</span><span class="marker">(</span><span class="var">array</span><span class="marker">)</span> <span class="marker">{</span><br>
<span class="Enum">2:</span>        &emsp;<span class="keys">let</span> <span class="var">min</span><span class="operator">=</span><span class="num">100000</span><span class="marker">;</span><br>
<span class="Enum">3:</span>        &emsp;<span class="keys">let</span> <span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">4:</span>        &emsp;&emsp;<span class="loops">for</span><span class="marker">(</span><span class="keys">let</span> <span class="var">j</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><span class="var">j</span> <span class="operator"><</span><span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">j</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">5:</span>           &emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">6:</span> &emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">7:</span> &emsp;&emsp;&emsp;<span class="loops">for</span> <span class="marker">(</span><span class="keys">let</span><span class="var">i</span><span class="operator">=</span><span class="var">j</span><span class="marker">;</span><span class="var">i</span> <span class="operator"><</span> <span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">i</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">8:</span>        &emsp;&emsp;&emsp;&emsp;<span class="conditions">if</span><span class="marker">(</span><span class="var">min</span><span class="operator">></span> <span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">){</span><br>
<span class="Enum">9:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">10:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">11:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">12:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="operator">=</span><span class="var">temp</span><span class="marker">;</span><br>
<span class="Enum">13:</span>&emsp;&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">14:</span>&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">15:</span>&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">16:</span>&emsp;<span class="keys">return</span> <span class="var">array</span><span class="marker">;</span><br>
<span class="Enum">17:</span>&emsp;<span class="marker">}</span><br>
 </p>
   
    </p>

  </section>
  
   <section class="main-section" id="Inserting_sort">
    <header>Inserting Sort</header>
    <p>
   This method works by building up a sorted array at the beginning of the list. It begins the sorted array with the first element. Then it inspects the next element and swaps it backwards into the sorted array until it is in sorted position. It continues iterating through the list and swapping new items backwards into the sorted portion until it reaches the end. This algorithm has quadratic time complexity in the average and worst cases.
      
        <p class="code">
      <code>
<span class="Enum">1:</span>&emsp;<span class="key-function">function</span> <span class="function">selectionSort</span><span class="marker">(</span><span class="var">array</span><span class="marker">)</span> <span class="marker">{</span><br>
<span class="Enum">2:</span>        &emsp;<span class="keys">let</span> <span class="var">min</span><span class="operator">=</span><span class="num">100000</span><span class="marker">;</span><br>
<span class="Enum">3:</span>        &emsp;<span class="keys">let</span> <span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">4:</span>        &emsp;&emsp;<span class="loops">for</span><span class="marker">(</span><span class="keys">let</span> <span class="var">j</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><span class="var">j</span> <span class="operator"><</span><span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">j</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">5:</span>           &emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">6:</span> &emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">7:</span> &emsp;&emsp;&emsp;<span class="loops">for</span> <span class="marker">(</span><span class="keys">let</span><span class="var">i</span><span class="operator">=</span><span class="var">j</span><span class="marker">;</span><span class="var">i</span> <span class="operator"><</span> <span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">i</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">8:</span>        &emsp;&emsp;&emsp;&emsp;<span class="conditions">if</span><span class="marker">(</span><span class="var">min</span><span class="operator">></span> <span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">){</span><br>
<span class="Enum">9:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">10:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">11:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">12:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="operator">=</span><span class="var">temp</span><span class="marker">;</span><br>
<span class="Enum">13:</span>&emsp;&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">14:</span>&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">15:</span>&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">16:</span>&emsp;<span class="keys">return</span> <span class="var">array</span><span class="marker">;</span><br>
<span class="Enum">17:</span>&emsp;<span class="marker">}</span><br>
 </p>
   
      
      
      
    </p>

  </section>
  
   <section class="main-section" id="Quick_sort">
    <header>Quick Sort</header>
    <p>
  Quick sort is an efficient, recursive divide-and-conquer approach to sorting an array. In this method, a pivot value is chosen in the original array. The array is then partitioned into two subarrays of values less than and greater than the pivot value. We then combine the result of recursively calling the quick sort algorithm on both sub-arrays. This continues until the base case of an empty or single-item array is reached, which we return. The unwinding of the recursive calls return us the sorted array.
      
      
    <p class="code">
      <code>
<span class="Enum">1:</span>&emsp;<span class="key-function">function</span> <span class="function">selectionSort</span><span class="marker">(</span><span class="var">array</span><span class="marker">)</span> <span class="marker">{</span><br>
<span class="Enum">2:</span>        &emsp;<span class="keys">let</span> <span class="var">min</span><span class="operator">=</span><span class="num">100000</span><span class="marker">;</span><br>
<span class="Enum">3:</span>        &emsp;<span class="keys">let</span> <span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">4:</span>        &emsp;&emsp;<span class="loops">for</span><span class="marker">(</span><span class="keys">let</span> <span class="var">j</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><span class="var">j</span> <span class="operator"><</span><span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">j</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">5:</span>           &emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">6:</span> &emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">7:</span> &emsp;&emsp;&emsp;<span class="loops">for</span> <span class="marker">(</span><span class="keys">let</span><span class="var">i</span><span class="operator">=</span><span class="var">j</span><span class="marker">;</span><span class="var">i</span> <span class="operator"><</span> <span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">i</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">8:</span>        &emsp;&emsp;&emsp;&emsp;<span class="conditions">if</span><span class="marker">(</span><span class="var">min</span><span class="operator">></span> <span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">){</span><br>
<span class="Enum">9:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">10:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">11:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">12:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="operator">=</span><span class="var">temp</span><span class="marker">;</span><br>
<span class="Enum">13:</span>&emsp;&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">14:</span>&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">15:</span>&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">16:</span>&emsp;<span class="keys">return</span> <span class="var">array</span><span class="marker">;</span><br>
<span class="Enum">17:</span>&emsp;<span class="marker">}</span><br>
 </p>
   
      
    </p>

  </section>
 <section class="main-section" id="Merge_sort">
    <header>Merge Sort</header>
    <p>
  Like quick sort, merge sort also uses a divide-and-conquer, recursive methodology to sort an array. It takes advantage of the fact that it is relatively easy to sort two arrays as long as each is sorted in the first place. But we'll start with only one array as input, so how do we get to two sorted arrays from that? Well, we can recursively divide the original input in two until we reach the base case of an array with one item. A single-item array is naturally sorted, so then we can start combining. This combination will unwind the recursive calls that split the original array, eventually producing a final sorted array of all the elements. The steps of merge sort, then, are:
<ol>
<li/>Recursively split the input array in half until a sub-array with only one element is produced.

<li/> Merge each sorted sub-array together to produce the final sorted array.
    </ol>
Merge sort is an efficient sorting method, with time complexity of O(nlog(n)). This algorithm is popular because it is performant and relatively easy to implement.
   
   <p class="code">
      <code>
<span class="Enum">1:</span>&emsp;<span class="key-function">function</span> <span class="function">selectionSort</span><span class="marker">(</span><span class="var">array</span><span class="marker">)</span> <span class="marker">{</span><br>
<span class="Enum">2:</span>        &emsp;<span class="keys">let</span> <span class="var">min</span><span class="operator">=</span><span class="num">100000</span><span class="marker">;</span><br>
<span class="Enum">3:</span>        &emsp;<span class="keys">let</span> <span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">4:</span>        &emsp;&emsp;<span class="loops">for</span><span class="marker">(</span><span class="keys">let</span> <span class="var">j</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><span class="var">j</span> <span class="operator"><</span><span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">j</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">5:</span>           &emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">6:</span> &emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="num">0</span><span class="marker">;</span><br>
<span class="Enum">7:</span> &emsp;&emsp;&emsp;<span class="loops">for</span> <span class="marker">(</span><span class="keys">let</span><span class="var">i</span><span class="operator">=</span><span class="var">j</span><span class="marker">;</span><span class="var">i</span> <span class="operator"><</span> <span class="var">array</span><span class="operator">.</span><span class="function">length</span><span class="marker">;</span><span class="var">i</span><span class="operator">++</span><span class="marker">){</span><br>
<span class="Enum">8:</span>        &emsp;&emsp;&emsp;&emsp;<span class="conditions">if</span><span class="marker">(</span><span class="var">min</span><span class="operator">></span> <span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">){</span><br>
<span class="Enum">9:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">min</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">10:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">temp</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">11:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">j</span><span class="rightP">]</span><span class="operator">=</span><span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="marker">;</span><br>
<span class="Enum">12:</span>&emsp;&emsp;&emsp;&emsp;&emsp;<span class="var">array</span><span class="leftP">[</span><span class="var">i</span><span class="rightP">]</span><span class="operator">=</span><span class="var">temp</span><span class="marker">;</span><br>
<span class="Enum">13:</span>&emsp;&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">14:</span>&emsp;&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">15:</span>&emsp;&emsp;<span class="marker">}</span><br>
<span class="Enum">16:</span>&emsp;<span class="keys">return</span> <span class="var">array</span><span class="marker">;</span><br>
<span class="Enum">17:</span>&emsp;<span class="marker">}</span><br>
 </p>
   
   
   
    </p>

  </section>

<section class="main-section" id="Binary_Search">
<header>Binary Search</header>
<p>
Binary search is an O(log(n)) efficiency algorithm for searching a sorted array to find an element. It operates using the following steps:
<ol>
<li/>Find the middle value of a sorted array. If value == target return (found it!).
<li/>If middle value < target, search right half of array in next compare.
<li/>If middle value > target, search left half of array in next compare.
 </ol>
As you can see, you are successively halving an array, which gives you the log(n) efficiency. For this challenge, we want you to show your work - how you got to the target value... the path you took!
</p>
</section>
  
<section class="main-section" id="Big_O">
<header>Big O</header>
<p>
In computer science, big O notation is used to classify algorithms according to how their run time or space requirements grow as the input size grows.[3] In analytic number theory, big O notation is often used to express a bound on the difference between an arithmetical function and a better understood approximation; a famous example of such a difference is the remainder term in the prime number theorem. Big O notation is also used in many other fields to provide similar estimates.
Big O notation characterizes functions according to their growth rates: different functions with the same growth rate may be represented using the same O notation. The letter O is used because the growth rate of a function is also referred to as the order of the function. A description of a function in terms of big O notation usually only provides an upper bound on the growth rate of the function.
</p>
</section>
<section class="main-section" id="Time_Complexity">
<header>Time Complexity</header>
<p>
Time complexity is the amount of time taken by an algorithm to run, as a function of the length of the input. It measures the time taken to execute each statement of code in an algorithm.
</p>
</section>
  <br>
<br>
<br>
<br>

</main>
*{
  border-sizing:box-sizing;
  font-family:arial;
}
#navbar::-webkit-scrollbar {
  display: none;
}

/* Hide scrollbar for IE, Edge and Firefox */
#navbar{
  -ms-overflow-style: none;  /* IE and Edge */
  scrollbar-width: none;  /* Firefox */
}
#navbar header{
  background:rgb(80,160,160);
  color:white;
  border-radius:10px 10px 10px 10px; 
  padding:10px;
  
}
a{
  color:rgb(5,90,125);
  
  background:rgb(220,220,255);
  margin:4px auto;
  border:3px solid rgb(100,100,125);
  border-radius:8px 8px 8px 8px;
  text-decoration:inherit;
  display:block;
  padding:10px;
  border-bottom:1px solid black;
  width:190px;
  text-align:center;
}
a:hover{
    background:lightblue;
}
.main-section header{
  color:rgb(0,10,130);
  font-weight:bold;
  border-bottom:2px solid rgb(0,10,130);
}
.main-section header:hover{
  background:lightgrey
}
section{
  margin-bottom:40px;
  
}
.code{
  padding:20px;
  border-radius:3px;
  background-color:rgb(20,30,30);
  line-height:25px;
  font-weight:400;
  font-size:1.2em;
  font-family: 'Nanum Gothic Coding', monospace;
  word-spacing: 5px;
  letter-spacing:1px;
}
#navbar{
 position: fixed;
 top: 0;
 border:1px solid black;
 width:220px;
 height:100%;
 z-index:1;
 overflow-y:scroll;
 overflow-x:hidden;
}
header{
  text-align:left;
  font-size:22px;
}
.main-section{
 
 margin-left:250px;
}
@media (max-width:600px){
  .main-section{
 margin-left:30px;
}
  #navbar{
    width:90%;
   
     position: relative;
     margin:auto;
  }
  a{
    width:100%;
    
  }
}
.marker{
  color:rgb(200,120,0);
  font-weight:700;
}
.key-function{
  color:rgb(220,65,60);
}
.function{
  color:white;
  font-weight:normal;
}
.keys{
  color:rgb(200,200,50);
}
.loops{
  color:rgb(10,200,200)
}
.conditions{
    color:rgb(200,50,50);
      font-weight:700;
    font-style: italic;
}
.var{
  color:rgb(80,120,180);
  font-weight:700;
}
.operator{
  color:rgb(200,50,50);
}
.num{
  color:rgb(150,160,180);
  font-family: 'Fira Code', monospace;
}
.leftP{
  color:orange;
  font-weight:normal;
}
.rightP{
  color:orange;
  font-weight:normal;
}
.Enum{
  font-family: 'Fira Code', monospace;
  font-weight:normal;
 color:rgb(70,80,100);
  font-style: italic;
}
.dark{
  height:32px;
  float:right;
}
function dark(){
  alert("dark")
var temp=  document.getElementsByClassName("code")
 for(let i=0;i<temp.length;i++){
 temp[i].style.background="rgb(220,220,200)";
 }
  
  var temp=  document.getElementsByClassName("rightP")
 for(let i=0;i<temp.length;i++){
 temp[i].style.color="darkorange";
 }
   var temp=  document.getElementsByClassName("leftP")
 for(let i=0;i<temp.length;i++){
 temp[i].style.color="darkorange";
 }
   var temp=  document.getElementsByClassName("num")
 for(let i=0;i<temp.length;i++){
 temp[i].style.color="rgb(50,60,80)";
 }
     var temp=  document.getElementsByClassName("operator")
 for(let i=0;i<temp.length;i++){
 temp[i].style.color="rgb(90,10,10)";
 }
  
  var temp=  document.getElementsByClassName("var")
 for(let i=0;i<temp.length;i++){
 temp[i].style.color="rgb(0,20,80)";
 }
   var temp=  document.getElementsByClassName("condition")
 for(let i=0;i<temp.length;i++){
 temp[i].style.color="rgb(30,100,100)";
 }
}
View Compiled
Run Pen

External CSS

This Pen doesn't use any external CSS resources.

External JavaScript

  1. https://cdn.freecodecamp.org/testable-projects-fcc/v1/bundle.js