docs: auto-sync Rosetta Code examples from zenc repo

Author: github-actions[bot]

rosetta/Array_concatenation.md

@@ -6,7 +6,8 @@ title = "Array concatenation"
 
 Zen C is a systems language that provides both low-level memory control and high-level standard library abstractions. Here are two idiomatic ways to concatenate collections.
 
-=== Using Raw Arrays ===
+### Using Raw Arrays
+
 For fixed-size C-style arrays, concatenation is typically done by allocating a new array and using fast memory block copying via <code>memcpy</code>.
 
 ```zc
@@ -38,7 +39,8 @@ fn main() {
 Concatenated array: [1, 2, 3, 4, 5]
 ```
 
-=== Using the Standard Library ===
+### Using the Standard Library
+
 For a more modern, ergonomic approach, Zen C's standard library provides a generic <code>Vec<T></code> type. Vectors support operator overloading, allowing them to be concatenated directly using the <code>+</code> operator.
 
 ```zc

rosetta/Array_length.md

@@ -6,7 +6,8 @@ title = "Array length"
 
 Zen C provides different ways to determine the number of elements depending on whether you are using raw fixed-size arrays or standard library vectors.
 
-=== Using Raw Arrays ===
+### Using Raw Arrays
+
 For raw C-style arrays, the number of elements is determined using the classic <code>sizeof</code> technique, dividing the total byte size of the array by the byte size of a single element.
 
 ```zc
@@ -26,7 +27,8 @@ fn main() {
 Raw array length: 2
 ```
 
-=== Using the Standard Library ===
+### Using the Standard Library
+
 When using the <code>Vec<T></code> type from the standard library, determining the number of elements is as simple as calling the <code>.length()</code> method.
 
 ```zc

rosetta/Binary_search.md

@@ -4,7 +4,7 @@ title = "Binary search"
 
 # Binary search
 
-=== Iterative ===
+### Iterative
 
 ```zc
 fn binary_search_iterative(arr: int*, value: int, low: int, high: int) -> int {
@@ -51,7 +51,7 @@ Value 5 not found.
 Value 20 found at index 9.
 ```
 
-=== Recursive ===
+### Recursive
 
 ```zc
 fn binary_search_recursive(arr: int*, value: int, low: int, high: int) -> int {

rosetta/Code_Golf.md

@@ -4,7 +4,8 @@ title = "Code Golf"
 
 # Code Golf
 
-=== With Literals ===
+### With Literals
+
 Zen C allows string literals to be evaluated as statements to print them to standard output. By appending the <code>..</code> operator, the implicit trailing newline is suppressed, emitting exactly the 9 required characters.
 
 ```zc
@@ -13,7 +14,8 @@ fn main(){"Code Golf"..}
 
 Length: 24 bytes.
 
-=== Without Literals ===
+### Without Literals
+
 This version assumes the compiled executable is renamed to <code>Code Golf</code> and executed via <code>./Code Golf</code>. It uses the program's own execution path in <code>argv[0]</code>, offsets the pointer by 2 to skip the <code>./</code> prefix, and uses the POSIX <code>write</code> function to emit exactly 9 bytes to stdout (file descriptor 1). Omitting the explicit declaration for <code>write</code> triggers a compiler warning but saves bytes.
 
 ```zc
@@ -22,7 +24,8 @@ fn main(argc:int,argv:char**){write(1,argv[0]+2,9)}
 
 Length: 51 bytes.
 
-=== Executable Size ===
+### Executable Size
+
 A standard build produces an executable of around **17KB**. However, when the binary is stripped and compiled using the Tiny C Compiler (TCC) backend, the footprint can be reduced to just **8.6KB**.
 
 ---

rosetta/FizzBuzz.md

@@ -6,7 +6,8 @@ title = "FizzBuzz"
 
 Zen C offers multiple ways to solve FizzBuzz. Here are two approaches: one using standard <code>if/else</code> statements and another using the <code>match</code> control flow feature.
 
-=== Using if/else ===
+### Using if/else
+
 This approach demonstrates Zen C's inclusive range loops (<code>..=</code>), basic modulo arithmetic, and implicit string interpolation.
 
 ```zc
@@ -25,7 +26,8 @@ fn main() {
 }
 ```
 
-=== Using match ===
+### Using match
+
 This implementation utilizes the <code>match</code> statement, which serves as a powerful alternative to <code>switch</code>. It supports multiple value matching on a single branch using commas, and includes a catch-all wildcard (<code>_</code>).
 
 ```zc

rosetta/Hello_world_Newbie.md

@@ -7,11 +7,13 @@ title = "Hello world/Newbie"
 Zen C is a modern systems programming language that compiles to human-readable GNU C/C.<br>
 Docs and the like can be found on it's [https://github.com/zenc-lang/zenc github] page. <br>
 
-===Supported Platforms and Backends===
+### Supported Platforms and Backends
+
 The Zen C compiler, <code>zc</code>, has support for Windows, macOS and Linux. As it is a transpiler (a source-to-source compiler), it acts as a front-end, requiring a back-end. Some of the available backends are <code>gcc</code>, <code>clang</code>, <code>tcc</code>, <code>zig cc</code>. The list is not exhaustive. By default, <code>gcc</code> will be used, but you can specify the back-end with the <code>--cc</code> flag.
 
-===Installation===
-====Compile from source====
+### Installation
+
+#### Compile from source
 
 ```zc
 git clone https://github.com/zenc-lang/zenc.git
@@ -23,7 +25,7 @@ sudo make install
 
 If you are on Windows you can build using the provided batch script, <code>build.bat</code>.
 
-===Example===
+### Example
 
 ```zc
 fn main() {

rosetta/Repeat.md

@@ -4,7 +4,7 @@ title = "Repeat"
 
 # Repeat
 
-=== Standard Closures ===
+### Standard Closures
 
 ```zc
 // The procedure accepts a standard closure and an integer
@@ -29,7 +29,7 @@ Hello from closure!
 Hello from closure!
 ```
 
-=== State-Capturing Closures ===
+### State-Capturing Closures
 
 ```zc
 // Reusing the 'times' procedure defined above
@@ -52,7 +52,7 @@ Iteration 4
 Iteration 5
 ```
 
-=== Raw Function Pointers ===
+### Raw Function Pointers
 
 ```zc
 // The procedure accepts a raw C-style function pointer