Update README.md

README.md

@@ -20,6 +20,12 @@ pipeline_tag: text-generation
 A small Qwen 3  4 billion parameter model trained on [nvidia/OpenCodeReasoning](https://huggingface.co/datasets/nvidia/OpenCodeReasoning) for coding tasks.
 For Coding, it is recommended to be in thinking mode.  
 
+## Recomended parameters:
+- Context window : > 10000
+- Temperature : 0.7
+- Top_p : 20
+- Top_k : 0.95
+
 ## Strengths 
 - Code generation
 - Logical question answering
@@ -33,4 +39,173 @@ For Coding, it is recommended to be in thinking mode.
 - [transformers](https://github.com/QwenLM/Qwen3?tab=readme-ov-file#run-qwen3)
 
 ### GGUF VERSION
-[gguf](https://huggingface.co/ertghiu256/qwen3-4b-code-reasoning-gguf) 
+[gguf](https://huggingface.co/ertghiu256/qwen3-4b-code-reasoning-gguf) 
+
+## Example Usage : 
+```
+> Write me a snake game in python. Ensure all keybinding (WASD) work properly and all mechanics from the original snake game works. /think
+<think>
+Okay, I need to write a Snake game in Python where all the keybindings (WASD) work properly and all the original mechanics are included. Let me think about how to approach this.
+
+First, I remember that the classic Snake game works by having a snake move in a direction, grow when it eats food, and die if it hits the wall or itself. The keybindings should allow the snake to change direction using W, A, S, D. But I need to make sure that the movement is smooth and that the snake can't reverse direction immediately, which might cause it to collide with itself right away.
+
+So, the plan is to use the pygame library because it's commonly used for game development in Python. I'll need to initialize the game window, set up the display, handle the game loop, manage the snake's movement, check for collisions, and handle the food.
+
+Let me outline the steps:
+
+Import necessary modules: Pygame, sys, random for generating food, time for delay.
+Initialize Pygame: Set up the display, clock, fonts, etc.
+Define constants: Screen size, grid size (like 20x20), snake speed, colors.
+Create the Snake class: Each segment of the snake. The snake moves in a direction, and each segment follows the previous one.
+Create the Food class: Randomly placed on the screen, and when eaten, the snake grows.
+Game loop:
+Handle events (WASD for direction).
+Move the snake.
+Check for collisions (walls or self).
+Check if food is eaten, then increase length.
+Update the display.
+Control the game speed with a clock.
+Handle keybindings: Make sure that the snake can't reverse direction. So, if the current direction is right, the next can't be left, and so on.
+Wait, but in the original Snake game, ...(Too long)
+</think>
+
+Here's a complete implementation of the **Snake Game** using the `pygame` library. The game allows the player to control the snake using the **WASD keys**, and the snake moves in the direction of the last key pressed. The game ends when the snake collides with the wall or itself, and the snake grows by one segment each time it eats the food.
+
+---
+
+### ✅ Features:
+- **WASD Controls**:
+  - `W` → Up
+  - `A` → Left
+  - `S` → Down
+  - `D` → Right
+- **Food Generation**:
+  - Randomly placed on a 32×24 grid (640×480 pixels).
+- **Game Over**:
+  - Ends when the snake hits the wall or itself.
+- **Speed Control**:
+  - Set with `clock.tick(10)` to control the game speed.
+
+---
+
+### 🧠 How It Works:
+1. The snake starts with 3 segments.
+2. The player uses `W`, `A`, `S`, `D` to change the direction.
+3. The snake moves in the current direction, growing if it eats the food.
+4. When the snake collides with the wall or itself, the game ends.
+
+---
+
+### 📦 Code Implementation
+
+```python
+import pygame
+import sys
+import random
+
+# Initialize Pygame
+pygame.init()
+
+# Game settings
+SCREEN_WIDTH = 640
+SCREEN_HEIGHT = 480
+BLOCK_SIZE = 20
+GRID_WIDTH = SCREEN_WIDTH // BLOCK_SIZE
+GRID_HEIGHT = SCREEN_HEIGHT // BLOCK_SIZE
+
+# Colors
+BLACK = (0, 0, 0)
+GREEN = (0, 255, 0)
+RED = (255, 0, 0)
+
+# Initialize screen
+screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+pygame.display.set_caption("Snake Game")
+
+# Clock
+clock = pygame.time.Clock()
+
+# Snake
+snake_segments = [(3, 3), (2, 3), (1, 3)]
+direction = (1, 0)  # Start moving right
+
+# Food
+def generate_food():
+    while True:
+        x = random.randint(0, GRID_WIDTH - 1)
+        y = random.randint(0, GRID_HEIGHT - 1)
+        if (x, y) not in snake_segments:
+            return (x, y)
+
+food = generate_food()
+
+# Game loop
+running = True
+ate_food = False
+
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        elif event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_w:
+                direction = (0, -1)
+            elif event.key == pygame.K_a:
+                direction = (-1, 0)
+            elif event.key == pygame.K_s:
+                direction = (0, 1)
+            elif event.key == pygame.K_d:
+                direction = (1, 0)
+
+    # Move the snake
+    new_head = (snake_segments[0][0] + direction[0], snake_segments[0][1] + direction[1])
+    snake_segments.insert(0, new_head)
+    if not ate_food:
+        snake_segments.pop()
+    ate_food = False
+
+    # Check for collisions
+    if (new_head[0] < 0 or new_head[0] >= GRID_WIDTH or
+        new_head[1] < 0 or new_head[1] >= GRID_HEIGHT):
+        pygame.quit()
+        sys.exit()
+    if new_head in snake_segments[1:]:
+        pygame.quit()
+        sys.exit()
+
+    # Check if food is eaten
+    if new_head == food:
+        food = generate_food()
+        ate_food = True
+
+    # Draw everything
+    screen.fill(BLACK)
+    for segment in snake_segments:
+        pygame.draw.rect(screen, GREEN, (segment[0] * BLOCK_SIZE, segment[1] * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE))
+    pygame.draw.rect(screen, RED, (food[0] * BLOCK_SIZE, food[1] * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE))
+    pygame.display.flip()
+
+    # Control the game speed
+    clock.tick(10)
+
+pygame.quit()
+sys.exit()
+```⠀
+
+---
+
+### 🧪 How to Run:
+1. Install `pygame` using pip:
+   `pip install pygame`
+2. Save the code in a file, e.g., `snake_game.py`.
+3. Run the file using Python:
+   `python snake_game.py`
+
+---
+
+### 🚀 Tips:
+- The game is fast-paced. You can slow it down by increasing the value in `clock.tick(10)` (e.g., `clock.tick(15)`).
+- The snake starts in the middle of the screen, and the food is placed randomly.
+
+Enjoy playing the **Snake Game**! 🐍🎮
+```