Update README.md

README.md

@@ -37,7 +37,7 @@ model = AutoModelForCausalLM.from_pretrained(
 )
 
 # prepare the model input
-prompt = "Give me a short introduction to large language model."
+prompt = "Write a quick sort algorithm."
 messages = [
     {"role": "user", "content": prompt}
 ]
@@ -53,22 +53,123 @@ generated_ids = model.generate(
     **model_inputs,
     max_new_tokens=65536
 )
-output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist() 
+output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
 
-# parsing thinking content
-try:
-    # rindex finding 151668 (</think>)
-    index = len(output_ids) - output_ids[::-1].index(151668)
-except ValueError:
-    index = 0
-
-thinking_content = tokenizer.decode(output_ids[:index], skip_special_tokens=True).strip("\n")
-content = tokenizer.decode(output_ids[index:], skip_special_tokens=True).strip("\n")
-
-print("thinking content:", thinking_content) # no opening <think> tag
+content = tokenizer.decode(output_ids, skip_special_tokens=True)
 print("content:", content)
+
 """
-....will update later...
+content: Here's a quicksort algorithm implementation in Python:
+
+```python
+def quicksort(arr):
+    """
+    Sorts an array using the quicksort algorithm.
+
+    Args:
+        arr: List of comparable elements
+
+    Returns:
+        None (sorts in-place)
+    """
+    if len(arr) <= 1:
+        return
+
+    def partition(low, high):
+        """Partition function using the last element as pivot"""
+        pivot = arr[high]
+        i = low - 1  # Index of smaller element
+
+        for j in range(low, high):
+            if arr[j] <= pivot:
+                i += 1
+                arr[i], arr[j] = arr[j], arr[i]  # Swap elements
+
+        arr[i + 1], arr[high] = arr[high], arr[i + 1]  # Place pivot in correct position
+        return i + 1
+
+    def quicksort_helper(low, high):
+        """Recursive helper function"""
+        if low < high:
+            # Partition the array and get pivot index
+            pi = partition(low, high)
+
+            # Recursively sort elements before and after partition
+            quicksort_helper(low, pi - 1)
+            quicksort_helper(pi + 1, high)
+
+    quicksort_helper(0, len(arr) - 1)
+
+# Example usage:
+if __name__ == "__main__":
+    # Test the algorithm
+    test_array = [64, 34, 25, 12, 22, 11, 90]
+    print("Original array:", test_array)
+
+    quicksort(test_array)
+    print("Sorted array:", test_array)
+
+    # Test with other examples
+    test_cases = [
+        [5, 2, 8, 1, 9],
+        [1],
+        [],
+        [3, 3, 3, 3],
+        [5, 4, 3, 2, 1]
+    ]
+
+    for i, case in enumerate(test_cases):
+        original = case.copy()
+        quicksort(case)
+        print(f"Test {i+1}: {original} → {case}")
+
+**How it works:**
+
+1. **Divide**: Choose a "pivot" element and partition the array so that elements smaller than the pivot are on the left, and larger elements are on the right.
+
+2. **Conquer**: Recursively apply quicksort to the sub-arrays on both sides of the pivot.
+
+3. **Combine**: Since we're sorting in-place, no additional combining step is needed.
+
+**Key features:**
+- **Time Complexity**: O(n log n) average case, O(n²) worst case
+- **Space Complexity**: O(log n) due to recursion stack
+- **In-place sorting**: Modifies the original array
+- **Not stable**: Relative order of equal elements may change
+
+**Alternative version with random pivot selection** (better average performance):
+
+```python
+import random
+
+def quicksort_random(arr):
+    """Quicksort with random pivot selection for better average performance"""
+    def partition(low, high):
+        # Randomly select pivot and swap with last element
+        random_index = random.randint(low, high)
+        arr[random_index], arr[high] = arr[high], arr[random_index]
+
+        pivot = arr[high]
+        i = low - 1
+
+        for j in range(low, high):
+            if arr[j] <= pivot:
+                i += 1
+                arr[i], arr[j] = arr[j], arr[i]
+
+        arr[i + 1], arr[high] = arr[high], arr[i + 1]
+        return i + 1
+
+    def quicksort_helper(low, high):
+        if low < high:
+            pi = partition(low, high)
+            quicksort_helper(low, pi - 1)
+            quicksort_helper(pi + 1, high)
+
+    if len(arr) > 1:
+        quicksort_helper(0, len(arr) - 1)
+
+The algorithm efficiently sorts arrays by repeatedly dividing them into smaller subproblems, making it one of the most widely used sorting algorithms in practice.
 """
 ~~~