Update README.md

README.md

@@ -14,11 +14,143 @@ Please follow the license of the original model.
 Llamacpp inference
 
 ~~~bash
-/llama-cli -hf Intel/gpt-oss-20b-gguf-q4ks-AutoRound
+llama-cli -hf Intel/gpt-oss-20b-gguf-q4ks-AutoRound
 ~~~
 
 ~~~bash
 > Write a quick sort algorithm.
+<|channel|>analysis<|message|>We need to write quick sort algorithm. The user wants a quick sort algorithm. Provide code? They didn't specify language. I can provide a general quick sort algorithm, maybe in Python, C++, Java, etc. Provide explanation. Provide typical implementation. I'll respond with explanation and code.<|start|>assistant<|channel|>final<|message|>Below is a minimal, self‑contained quick‑sort implementation in a few common languages.
+Feel free to copy‑paste the snippet that matches your stack, or use it as a template and adapt it to your needs.
+
+---
+
+## Quick‑Sort – Concept
+
+1. **Choose a pivot** – usually the first element (or median of three, etc.).
+2. **Partition** the array into two sub‑arrays:
+   * elements `< pivot`
+   * elements `>= pivot` (or `> pivot` if you want to avoid duplicates)
+3. **Recursively sort** the two sub‑arrays.
+4. **Concatenate** the sorted left part, the pivot, and the sorted right part.
+
+The algorithm is *in‑place* (no extra array for the whole list) and runs in average \(O(n \log n)\), worst‑case \(O(n^2)\) if the pivot is poorly chosen.
+
+---
+
+## 1. Python (in‑place)
+
+```python
+def quick_sort(arr, left=0, right=None):
+    """
+    Sorts `arr` in place using the Quick‑Sort algorithm.
+    """
+    if right is None:
+        right = len(arr) - 1
+
+    def _partition(lo, hi):
+        # choose the first element as pivot
+        pivot = arr[lo]
+        i, j = lo + 1, hi
+        while True:
+            while i <= hi and arr[i] < pivot:
+                i += 1
+            while j >= lo + 1 and arr[j] > pivot:
+                j -= 1
+            if i >= j:
+                break
+            arr[i], arr[j] = arr[j], arr[i]
+        # place pivot in its final position
+        arr[lo], arr[j] = arr[j], arr[lo]
+        return j
+
+    if left < right:
+        p = _partition(left, right)
+        quick_sort(arr, left, p - 1)
+        quick_sort(arr, p + 1, right)
+
+# ---- Example ----------------------------------------------------
+data = [3, 6, 8, 10, 1, 2, 1]
+quick_sort(data)
+print(data)   # -> [1, 1, 2, 3, 6, 8, 10]
+```
+
+**Notes**
+
+* The helper `_partition` returns the final index of the pivot.
+* The algorithm is *stable only if you change the comparison* to `<=` or `>=` depending on the ordering you need.
+* For very large lists you may want to switch to a non‑recursive implementation to avoid hitting Python’s recursion depth limit.
+
+---
+
+## 2. C++ (in‑place, STL‑like)
+
+```cpp
+#include <vector>
+#include <algorithm>   // for std::swap
+
+template<typename T>
+void quick_sort(std::vector<T>& a, int left = 0, int right = -1)
+{
+    if (right == -1) right = static_cast<int>(a.size()) - 1;
+
+    auto partition = [&](int lo, int hi) -> int {
+        T pivot = a[lo];
+        int i = lo + 1, j = hi;
+        while (true) {
+            while (i <= hi && a[i] < pivot) ++i;
+            while (j >= lo + 1 && a[j] > pivot) --j;
+            if (i >= j) break;
+            std::swap(a[i], a[j]);
+        }
+        std::swap(a[lo], a[j]); // pivot in place
+        return j;
+    };
+
+    if (left < right) {
+        int p = partition(left, right);
+        quick_sort(a, left, p - 1);
+        quick_sort(a, p + 1, right);
+    }
+}
+
+// ---- Example ----------------------------------------------------
+int main() {
+    std::vector<int> v{3, 6, 8, 10, 1, 2, 1};
+    quick_sort(v);
+    for (int x : v) std::cout << x << ' ';
+    // Output: 1 1 2 3 6 8 10
+}
+```
+
+---
+
+## 3. Java (in‑place)
+
+```java
+public static <T extends Comparable<? super T>> void quickSort(T[] a) {
+    quickSort(a, 0, a.length - 1);
+}
+
+private static <T extends Comparable<? super T>> void quickSort(T[] a,
+                                                                int left, int right) {
+    if (left >= right) return;
+
+    int pivotIdx = partition(a, left, right);
+    quickSort(a, left, pivotIdx - 1);
+    quickSort(a, pivotIdx + 1, right);
+}
+
+private static <T extends Comparable<? super T>> int partition(T[] a,
+                                                                int left, int right) {
+    T pivot = a[left];
+    int i = left + 1, j = right;
+
+    while (true) {
+        while (i <= right && a[i].compareTo(pivot) < 0) i++;
+        while (j >= left + 1 && a[j].compareTo(pivot) > 0) j--;
+        if (i >= j) break;
+        T tmp = a[i]; a[i] = a[j]; a[j] = tmp;
+    }
     // put pivot into final place
     T tmp = a[left]; a[left] = a[j]; a[j] = tmp;
     return j;